After embedding time.Time in a struct, why does json.Marshal emit only a timestamp and drop the other fields?

## What you see ```go type Event struct { time.Time ID string } ``` `json.Marshal(Event{})` produces a bare JSON string — `"0001-01-01T00:00:00Z"` — not an object, and `ID` appears nowhere. Decoding is broken in the same direction: `time.Time` also has `UnmarshalJSON`, promoted the same way, so the decoder hands the whole document to it and `ID` is never populated. Fields did not go missing from the object; there is no object. ## The mechanism, in two steps **Step one: promotion.** An embedded field contributes both its fields and its methods to the outer struct. `Event` therefore has a method `MarshalJSON` — the one declared on `time.Time`, reached through the embedded field. It is a real member of `Event`'s method set, not a convenience at the call site. **Step two: the interface check.** `encoding/json` asks whether the value's type implements `json.Marshaler` before it does anything else. `Event` does now. So the encoder calls `Event.MarshalJSON`, which is `time.Time.MarshalJSON` on the embedded value, and writes exactly what that returns. The reflective walk that would have produced `{"Time":...,"ID":...}` never runs, so no tag, no field, no `omitempty` has any effect. Nothing here is specific to `time.Time`; it is only the type people embed most. Any embedded type with a `MarshalJSON` — a shared `Base` in an internal library, a wrapper around a decimal, an ID type that renders as a string — hijacks its container the same way. The hijack is also transitive: a struct embedding `Event` inherits the promoted method again. ## Why it survives review and tests The compiler is happy: `Event` is a perfectly good type. `go vet` says nothing. A round-trip test can pass, because encoding and decoding are hijacked symmetrically — the timestamp survives the trip, and if the test only asserts on the timestamp it goes green with `ID` quietly lost. The failure shows up as a consumer complaining that a field "never arrives", or as an empty column downstream. What catches it is a golden test: assert the exact bytes for a fully populated value. What catches it in review is a rule of thumb — **embedding a type into a struct you serialise is a decision, not a shortcut** — and a habit of asking what methods the embedded type brings with it. ## The fixes, in order of preference **Name the field.** `At time.Time \`json:"at"\`` restores the ordinary struct encoding: `time.Time`'s marshaler is then used for that *field*, which is what you wanted, and the other fields come back. This is almost always the right answer, because the embedding was rarely buying anything except a shorter selector. **Give the embedded field a JSON tag name.** A tagged anonymous field is treated as a named member for encoding purposes. It fixes the wire shape but leaves the promoted method in the type's method set, so the outer struct still satisfies `json.Marshaler` and still hijacks itself. Not a fix. **Write the outer type's own MarshalJSON.** If the embedding is load-bearing for the Go API, declare `func (e Event) MarshalJSON()` on the outer type; a method declared on the outer type shadows the promoted one at the same depth, and the encoder calls yours. You then decide the shape explicitly — and you owe a matching `UnmarshalJSON`, since the decoding side is hijacked too. A trap inside that fix: the usual `type plain Event` trick does **not** help here. A type definition drops methods declared on `Event`, but the embedded field travels with the struct, so `plain` still promotes `time.Time`'s `MarshalJSON` and marshaling it recurses right back into a timestamp string. To use the wrapper pattern you must shadow the embedded field in the wrapper struct — declare a member with the same JSON name at the outer level so the shallower field wins — or, again, just name the field. ## The library-boundary angle This is worth flagging because the damage is asymmetric. When the struct is internal, someone notices in a day. When it is in a package other teams import and embed into *their* wire types, the promoted method rides along into payloads you never see, and the fix is a breaking change to a type you published. If a library exports a type meant to be embedded, either keep it free of `MarshalJSON` and `UnmarshalJSON`, or document loudly that embedding it takes over the container's JSON — and prefer exporting it as a named field in your own wire structs so no one learns the pattern from your examples.