observe

func Chain ¶

func Chain(deps Deps) []connect.Interceptor

Chain returns the canonical Connect interceptor chain for a project composed with EXPLICIT collaborators — the per-server composition-root counterpart to DefaultMiddlewares.

The order is the canonical forge order, with the application layer (deadline → auth → audit → rate-limit) sitting INNER to the observability layer and OUTER to the handler, exactly the position DefaultMiddlewares documents for Extras:

0. Trace — the server span (Deps.Trace, when non-nil), then the pprof labels naming it and the traceresponse header returning its context to the caller (TraceResponseInterceptor). Outside everything below, so the span covers recovery, logging and auth, and their log lines carry its ids.
1. RecoveryInterceptor — observes panics from everything below.
2. RequestIDInterceptor — mints/propagates the correlation id early.
3. LoggingInterceptor — every failure; every success, or a sample of them when sampling is turned on.
4. TracingInterceptor — one OTel span per RPC.
5. MetricsInterceptor — calls/errors/duration.
6. Deadline — the RPC's time budget: Deps.Deadline, Deadline{} when nil, none for serverkit.NoDeadline. Ahead of auth, so authenticating runs inside the RPC's deadline.
7. Auth — authenticate (when non-nil). Inner to observability so auth failures are still logged / traced / counted.
8. Audit — durable audit record (when non-nil); runs after auth so it sees the authenticated principal.
9. RateLimit — throttle (when non-nil); keyed off the authenticated subject auth attached, so it follows auth.
10. Extras — remaining project interceptors, in order.
11. svcerr.Interceptor — always last, next to the handler, so a handler's svcerr error becomes its Connect error (PermissionDenied is permission_denied, not unknown) before audit, logging and metrics read it. Not a slot: an svcerr.Interceptor passed in Extras is moved here, not run twice.

nil collaborator fields are simply skipped — the chain has no fixed length (unlike the observability-only DefaultMiddlewares, which keeps a stable length via no-op interceptors) — except Deadline, whose nil is forge's default budget. A worker process passing all-nil application collaborators gets the observability chain plus that budget.

func ClientRequestIDInterceptor ¶

func ClientRequestIDInterceptor() connect.Interceptor

ClientRequestIDInterceptor returns a Connect interceptor for OUTBOUND clients that forwards the correlation ID already on ctx (see RequestIDFromContext) as the RequestIDHeader on the outgoing request, so the callee's logs carry the same request_id as the caller's. An ID already present on the outgoing header is left untouched; a ctx without an ID forwards nothing (the callee mints its own).

It is included in NewClientStack's canonical chain; it is exported for projects assembling a bespoke client chain.

func ContextWithRequestID ¶

func ContextWithRequestID(ctx context.Context, id string) context.Context

ContextWithRequestID attaches id to ctx so downstream handlers and log call sites can correlate work across goroutines.

func DefaultMiddlewares ¶

func DefaultMiddlewares(deps DefaultMiddlewareDeps) []connect.Interceptor

DefaultMiddlewares returns the canonical Connect interceptor chain for forge-generated services.

Order, and why ¶

The order is:

1. RecoveryInterceptor — outermost; observes panics from every subsequent layer + the handler. If you put it later, an interceptor crash propagates to the client as a torn connection instead of a clean Internal error.

2. RequestIDInterceptor — runs early so log records, traces, and metrics from later layers can attribute themselves to the same request ID. Trusts an inbound RequestIDHeader when present, mints a fresh ID otherwise.

3. LoggingInterceptor — logs every failed RPC and every successful one, or a per-procedure sample of the successes when sampling is turned on (see LoggingInterceptor). Sits before tracing/metrics so its timing reflects ALL inner cost (including the OTel work itself). Logging is cheap; the placement is about "this is what the user paid".

4. TracingInterceptor — wraps the handler in an OTel span. Inner to logging so the span name is stable per procedure even when auth rewrites context.

5. MetricsInterceptor — innermost observability layer. Records calls/errors/duration. Sitting after tracing means the duration histogram measures handler-only time (excluding upstream observability cost), which is the more meaningful number.

6. Extras — project-specific interceptors. The canonical position for auth, rate-limit, idempotency is INNER to observability (so failures from those layers still get logged, traced and counted) and OUTER to the handler. DefaultMiddlewares appends Extras in the order supplied; callers control inter-Extra ordering.

7. svcerr.Interceptor — always last, next to the handler: a handler's svcerr error becomes its Connect error before any layer above reads it. Not a slot; an svcerr.Interceptor passed in Extras is moved here, not run twice.

Auth-first vs auth-last ¶

A reasonable alternative is "auth at position 1, before everything else" — the case being that observability of unauthenticated traffic is noise. The forge default is auth-after-observability for two reasons:

1. Operators want to see authentication failures (count, rate, source) in the same dashboards they see successful traffic. Logging and metrics need to run.
2. The Connect handler's procedure routing (which the observability layer attributes against) happens BEFORE any interceptor, so observability sees procedure regardless of order.

Projects that disagree can build a custom chain — DefaultMiddlewares is opinionated, not mandatory.

nil deps ¶

nil tracer / nil meter degrade to pass-through interceptors. nil logger falls back to slog.Default. This makes DefaultMiddlewares safe to wire from a test harness that doesn't configure OTel.

func ErrorGroup ¶ added in v1.0.0

func ErrorGroup(_ context.Context, name string) slog.Attr

ErrorGroup returns the attribute that pins a record to a named issue, whatever its message, call site or error type: the escape hatch when the derived grouping is wrong for one failure.

logger.ErrorContext(ctx, "reconcile drift", "err", err,
	observe.ErrorGroup(ctx, "billing-reconcile-drift"))

func FromContext ¶

func FromContext(ctx context.Context) *slog.Logger

FromContext returns the *slog.Logger previously stored by WithLogger, or slog.Default() when none is present (or a nil one was stored). It never returns nil, so call sites can log unconditionally:

observe.FromContext(ctx).Info("doing the thing", "id", id)

This is the read half of the logger-from-context convention that lets non-server shapes (CLI commands, standalone binaries) share the server logger without a global or an extra parameter.

func IssueSource ¶ added in v1.0.0

func IssueSource(_ context.Context, name string) slog.Attr

IssueSource returns the attribute that makes a record an issue event of the named source, at whatever level it is logged: the issues pipeline groups it (by its fingerprint, which ErrorGroup can pin) into issues of that source, listed apart from errors (`forge obs issues --source <name>`). Errors carry no source. Use it for a report that must be triaged like an error without counting as one — an error rate, an error alert or a release-health gate never sees it unless it is also logged at ERROR.

logger.WarnContext(ctx, "[reliant] message truncated",
	observe.IssueSource(ctx, "llm_bug_report"),
	observe.ErrorGroup(ctx, "llm_bug_report/reliant/message truncated"))

func LevelForError ¶

func LevelForError(err error) slog.Level

LevelForError is the single place that decides how loud a failed call is, under the default policy (see error_class.go).

Every failure used to log at WARN, including the ones that mean the SERVER is broken. A total database outage produced a stream of WARN records and a 500 for every request, so the standard alert rule — level=ERROR — stayed silent through the whole incident. Meanwhile a client sending a malformed field also logged WARN, which is why raising everything to ERROR is not the fix either: it just moves the noise.

The split is fault attribution — svcerr.Classify — not HTTP status:

• ERROR: the server failed and someone should be paged. Internal (a bug or a dependency down), Unavailable (a dependency refused), DataLoss, Unknown, and any error nothing classified.
• WARN: a server-side failure that says "retry", not "page" — DeadlineExceeded, Aborted, Unimplemented.
• DefaultUserErrorLevel (INFO): the request failed for a reason the server correctly detected, or the caller went away. NotFound, InvalidArgument, PermissionDenied, FailedPrecondition, ResourceExhausted, cancellations, and anything marked svcerr.WithClass(err, svcerr.ClassUser). These are the API working.

Exported so the audit interceptor and any project-owned logging site classify identically — two log streams disagreeing about severity for the same RPC is its own incident. A layer configured WithUserErrorLevel uses its own level for the user half.

func LogCall ¶

func LogCall(ctx context.Context, logger *slog.Logger, method string, start time.Time, err error)

LogCall emits a single slog.Info record summarising a wrapped operation that returns an error. Use it for opt-in per-method observability when one Service calls another and you want a log line at the inner boundary:

start := time.Now()
user, err := s.userStore.Get(ctx, id)
observe.LogCall(ctx, logger, "userstore.Get", start, err)

The record shape (msg = method, attrs = duration + error) matches what the now-removed middleware_gen.go used to emit, so dashboards keyed on those attribute names keep working.

nil-safe on logger.

func LogPanic ¶ added in v1.0.0

func LogPanic(ctx context.Context, logger *slog.Logger, msg string, recovered any, attrs ...slog.Attr)

LogPanic logs a recovered panic at ERROR on logger. Call it from the deferred function that called recover():

defer func() {
	if rec := recover(); rec != nil {
		observe.LogPanic(ctx, logger, "panic recovered", rec, slog.String("path", p))
	}
}()

The record's PC is the PANICKING frame, not the recover site, so a handler reading it (otelslog's code.function.name, slog's AddSource) groups panics by where they happened. The stack goes in exception.stacktrace; "panic" is the recovered value.

func LoggingInterceptor ¶

func LoggingInterceptor(logger *slog.Logger, opts ...LogOption) connect.Interceptor

LoggingInterceptor returns a Connect interceptor that logs RPCs: procedure, duration, request_id, and (on failure) error.

• Every FAILED call is written — "rpc failed" / "stream failed" — with the error, its cause, its error_class and its code, at the level its class earns (see error_class.go): ERROR for a server fault, the user-error level (INFO; WithUserErrorLevel) for a user error or a cancellation.
• Every SUCCESSFUL call is written — "rpc completed" / "stream completed", at INFO — unless WithSuccessSampling turns success sampling on for this layer. Sampled, a procedure's first success is written, then at most one per window, carrying `suppressed`, the successes of that procedure since the previous record that were not written. A unary success at or above DefaultSlowThreshold is always written, with slow=true. See log_policy.go.
• A failure whose error WithExpectedErrors declared an expected outcome is still "rpc failed" with its error — the client did get one — but is written like a success: at the procedure's success level, sampled with it, carrying expected=true.

opts tune the success half — WithSuccessSampling, WithSlowThreshold, WithSuccessLevel for one procedure, WithExpectedErrors — and the failure levels: WithUserErrorLevel, WithErrorClassifier. Through Chain / DefaultMiddlewares they are passed as Deps.LogOptions.

func MetricsInterceptor ¶

func MetricsInterceptor(meter metric.Meter) connect.Interceptor

MetricsInterceptor returns a Connect interceptor that records three OpenTelemetry metrics per RPC:

• rpc.server.calls (counter, attribute: procedure)
• rpc.server.errors (counter, attribute: procedure)
• rpc.server.duration (histogram seconds, attribute: procedure)

Streaming handlers record one duration sample per stream end. A nil meter disables metrics (interceptor is a pass-through), matching TracingInterceptor's behaviour for tracer == nil.

func NewErrorClassHandler ¶

func NewErrorClassHandler(inner slog.Handler, opts ...LogOption) slog.Handler

NewErrorClassHandler wraps inner so that EVERY record in the process obeys the error-class policy, not only the ones forge's interceptors write. A record above the user-error level that carries an error is classified:

• it gains error_class=<class> (unless it already carries one — a layer that classified it, such as LoggingInterceptor, is trusted);
• if the error is not a server fault, its level is lowered to the user-error level. A level is only ever lowered: a server error logged at WARN stays WARN, because the call site chose that.

The error is the first attribute whose value is an `error`, whatever its key ("error", "err", logr's "err"). Attributes bound earlier with Logger.With are not searched; an error belongs on the record that reports it. A record with no error attribute, or at or below the user-error level, passes through untouched and is not scanned.

Wrap it OUTSIDE anything that routes on level — a Sentry forwarder, an error counter — so they see the classified level:

handler := slog.NewJSONHandler(os.Stdout, opts)
handler = sentryHandler(handler)           // forwards >= ERROR
handler = observe.NewErrorClassHandler(handler)
slog.SetDefault(slog.New(handler))

opts are WithUserErrorLevel and WithErrorClassifier; other LogOptions concern call outcomes and are ignored here.

func NewHTTPClient ¶ added in v1.0.0

func NewHTTPClient(opts HTTPClientOptions) *http.Client

NewHTTPClient returns a fresh *http.Client whose every request is an OTel CLIENT span ("<METHOD> <host>"), carries the caller's trace context (W3C traceparent, through the global propagator observe.Setup installs) and its X-Request-Id. Fresh per call: a consumer may change CheckRedirect or Jar on it without affecting anyone else, while the default transport, and so the connection pool, is shared.

func NewHTTPTransport ¶ added in v1.0.0

func NewHTTPTransport(base http.RoundTripper) http.RoundTripper

NewHTTPTransport wraps base (nil: http.DefaultTransport) so every request through it is traced and forwards the request ID. otelhttp sits OUTSIDE the request-ID transport, so its span covers the whole round trip including the header the inner layer adds. Prefer NewHTTPClient; this is for a client whose construction you do not own.

func NewLogHandler ¶

func NewLogHandler(next slog.Handler, cfg Config) slog.Handler

NewLogHandler is the handler serverkit builds for the process logger: next (the stdout JSON or text handler) wrapped by NewTraceHandler. Every record at ERROR or above also gains the attributes an issue is grouped by — code.function.name, code.file.path, code.line.number, and for a record carrying an error exception.type and exception.message (see error_inputs.go) — on both shipping paths. When the OTLP logs switch is on (Config.OTLPLogs or OTEL_LOGS_EXPORTER=otlp) it is also teed into the OpenTelemetry logs bridge, which Setup connects to an OTLP exporter.

OTLP logs export is OFF by default and is the SECOND shipping path, not an addition to the first: the stdout stream is still written, so a workload that enables the OTLP exporter must not also be collected from its stdout/log files (the local collector's file reader, a cluster node agent), or every line arrives twice. Exactly one shipping path per environment.

Every line next writes (a JSON handler; a *slog.TextHandler is left alone) also carries the process resource under LogKeyResource: service.name, service.version, service.namespace, deployment.environment.name and service.instance.id, from the resource Setup builds for the traces and metrics — Setup's own once it has run, the same inputs (cfg and the OTEL_* environment) before. Pass the Config you pass Setup. The collector reading stdout lifts them into the record's resource; the OTLP bridge needs no stamp, because its provider carries the resource itself.

func NewRequestIDTransport ¶

func NewRequestIDTransport(base http.RoundTripper) http.RoundTripper

NewRequestIDTransport returns an http.RoundTripper that copies the correlation ID already on the request context (RequestIDFromContext — put there by the inbound RequestIDInterceptor or the HTTP RequestIDMiddleware) onto the outgoing RequestIDHeader, so the callee's logs carry the same request_id as the caller's.

An ID already present on the outgoing header is left untouched, and a context without an ID forwards nothing (the callee mints its own). A nil base uses http.DefaultTransport.

Wrap it in otelhttp for traces — request-ID forwarding and OTel spans are independent concerns and you want both; see the file header for the canonical composition.

func NewTraceHandler ¶

func NewTraceHandler(next slog.Handler) slog.Handler

NewTraceHandler wraps next so every record logged with a context holding a valid span carries trace_id and span_id. Records without a span, and records that already carry a trace_id attribute, pass through unchanged. The ids are only available to the *Context logging methods (InfoContext, LogAttrs, ...): slog.Info and friends have no context to read.

Under logger.WithGroup the ids are nested in the group, as with any attribute added after the group opens.

A record at WARN or above, logged with a recording span in its context, is also added to that span as an event — "log.warn" or "log.error", carrying the message, the level and the error (see LogEventWarn). The gateway's tail sampler keeps a trace that has one, so a request whose logs complained is never sampled away while its log lines survive. Wrap the handler INSIDE NewErrorClassHandler (as serverkit does) so the event follows the level the line is written at: a user error lowered to INFO adds none.

func ProfileLabelsMiddleware ¶

func ProfileLabelsMiddleware(next http.Handler) http.Handler

ProfileLabelsMiddleware labels the goroutine serving a plain net/http request with its span, for handlers that are not Connect RPCs (TracingInterceptor already covers those). Mount it INSIDE the otelhttp handler (or anything else that starts the server span).

func RecordSpanError ¶

func RecordSpanError(span trace.Span, err error)

RecordSpanError marks span as failed when err is non-nil: the error is recorded as a span event and the span status is set to Error. This is the one-liner the owned per-package observe.go wrappers call after each inner method invocation:

ctx, span := o.tracer.Start(ctx, "userstore.Get")
defer span.End()
out, err := o.inner.Get(ctx, id)
observe.RecordSpanError(span, err)

A server fault that svcerr captured a stack for (see svcerr.StackOf) carries it on the span's exception event as exception.stacktrace; a client-class error never does.

nil-safe on both span and err (a nil err is the no-op success path).

func RecoveryInterceptor ¶

func RecoveryInterceptor(logger *slog.Logger) connect.Interceptor

RecoveryInterceptor returns a Connect interceptor that recovers from panics inside downstream handlers, logs the recovered value plus the stack, and returns connect.CodeInternal so the client never sees a torn connection.

Place this FIRST in the chain so it observes panics from every subsequent interceptor and the handler itself.

func RequestIDFromContext ¶

func RequestIDFromContext(ctx context.Context) string

RequestIDFromContext returns the request ID stored on ctx (empty when absent). Nil-context safe.

func RequestIDInterceptor ¶

func RequestIDInterceptor() connect.Interceptor

RequestIDInterceptor returns a Connect interceptor that ensures every inbound request has a correlation ID. It resolves the ID in this order, and the order is the whole point:

1. An ID ALREADY ON THE CONTEXT wins. The HTTP edge (pkg/middleware.RequestIDMiddleware) sits outside this interceptor, and it has already picked the ID, written it to the RESPONSE header, and put it on ctx. It does not write it back onto the INBOUND request header, so an interceptor that only consulted req.Header() found nothing and minted a SECOND id — the response came back with two X-Request-Id values, every standard client read the first, and only the second ever reached the logs. Quoting an ID at support and grepping for it returned nothing.
2. Otherwise the inbound RequestIDHeader, so an edge proxy or calling service can stitch one ID across hops.
3. Otherwise a fresh 16-byte crypto/rand hex token.

ECHO OWNERSHIP follows from the same rule: whichever layer CHOSE the ID echoes it. When the ID came off the context, an outer layer chose it and this interceptor writes no response header at all — that is what keeps exactly one X-Request-Id on the wire. When this interceptor chose the ID (no HTTP middleware in the stack, e.g. a bare Connect mux) it echoes, so the client is never left without one.

Place this AFTER RecoveryInterceptor (so panics still get the ID in their log line) and BEFORE LoggingInterceptor (so log records inherit the ID).

func RunRoot ¶ added in v1.0.0

func RunRoot(ctx context.Context, name string, fn func(context.Context) error, opts ...trace.SpanStartOption) (err error)

RunRoot runs fn under a NEW ROOT span named name and ends it when fn returns. It is a new trace even when ctx already carries a span: a loop started inside a request must not file every later iteration under that request. The span records fn's error, and a panic in fn — recorded, then re-raised, so the caller's recovery policy still applies.

Name it for the work, not the instance: "worker.metering.tick", "reconcile Workspace". Put ids in attributes (opts), never in the name.

func SetAppVersion ¶ added in v1.0.0

func SetAppVersion(v string)

SetAppVersion sets the app.version stamped on product events. Setup calls it with Config.ServiceVersion; call it directly in a process that does not use Setup.

func Setup ¶

func Setup(ctx context.Context, cfg Config) (func(context.Context) error, http.Handler, error)

Setup initializes OpenTelemetry from Config plus the standard OTEL_* environment and installs the providers globally.

Always, even with export off: the W3C TraceContext+Baggage propagator is installed (so an incoming traceparent is honoured and forwarded by every observe client), and a Prometheus reader backs the returned /metrics handler.

When an OTLP endpoint is configured and OTEL_SDK_DISABLED is not "true": traces and metrics are exported over OTLP, http/protobuf by default or grpc when OTEL_EXPORTER_OTLP_PROTOCOL says so, with OTEL_EXPORTER_OTLP_HEADERS (and the per-signal variants) applied by the exporter; Go runtime metrics are recorded; and, only when explicitly switched on, logs are exported too.

It returns a shutdown function (flushes/stops the providers), an http.Handler for /metrics, and any error.

func TraceCall ¶

func TraceCall[T any](ctx context.Context, tracer trace.Tracer, operationName string, fn func(context.Context) (T, error)) (T, error)

TraceCall executes fn inside a new OpenTelemetry span named operationName and returns the inner result. Span errors are recorded when fn returns a non-nil error.

Use TraceCall to express the previous tracing_gen.go behaviour at explicit call sites:

user, err := observe.TraceCall(ctx, tracer, "userstore.Get", func(ctx context.Context) (User, error) {
    return s.userStore.Get(ctx, id)
})

nil-safe on tracer (executes fn directly, no span).

func TraceResponseInterceptor ¶ added in v1.0.0

func TraceResponseInterceptor() connect.Interceptor

TraceResponseInterceptor writes the traceresponse header for the server span on ctx. Place it directly inside the interceptor that opens that span — observe.Chain does — so the header names the span every log line and child span of the request hangs off.

Unary: on the response, and on a *connect.Error's metadata, which Connect sends as response headers, so a FAILED call names its trace too (the case that matters). An error that is not a *connect.Error is left untouched rather than rewrapped; forge handlers return svcerr-wrapped connect errors. Streaming: on the response headers before the handler runs.

func TraceResponseValue ¶ added in v1.0.0

func TraceResponseValue(sc trace.SpanContext) string

TraceResponseValue renders sc as a traceresponse value, or "" when sc is not a valid span context.

func TraceVoidCall ¶

func TraceVoidCall(ctx context.Context, tracer trace.Tracer, operationName string, fn func(context.Context) error) error

TraceVoidCall is the no-result variant of TraceCall, for operations that return only an error. Same semantics, no value.

func TracingInterceptor ¶

func TracingInterceptor(tracer trace.Tracer) connect.Interceptor

TracingInterceptor returns a Connect interceptor that creates one OpenTelemetry span per RPC. The span name is the full procedure ("/service.v1.Foo/Bar"); errors are recorded via span.RecordError + span.SetStatus(codes.Error, …).

A nil tracer disables tracing (interceptor is a pass-through). This keeps DefaultMiddlewares safe to wire in test harnesses that don't configure OTel.

func Track ¶ added in v1.0.0

func Track(ctx context.Context, name string, attrs ...slog.Attr)

Track records one product event: a named, countable thing a user did or that happened to them ("project_created", "subscription_started"). It writes an INFO record through the context's logger (FromContext) carrying event.name="product.<name>", app.client="backend", app.version, user.id when ctx holds an authenticated user (the claims forge's auth interceptor installs), and each attr as product.<key>.

Properties are bounded the same way the telemetry pipeline bounds them: at most MaxProductProps are kept and each value is truncated to MaxProductPropValueLen characters. Group attrs are flattened to "group.key". Property values are stringified; keep them low-cardinality and never put secrets or personal data in them.

Track never fails the caller. A name that is not snake_case is dropped with a warning, because the pipeline would drop it anyway.

observe.Track(ctx, "project_created", slog.String("template", "go"), slog.Int("repos", 2))

func TrustRemoteBy ¶ added in v1.0.0

func TrustRemoteBy(classify TraceTrustFunc, opts ...otelconnect.Option) (connect.Interceptor, error)

TrustRemoteBy returns the server tracing interceptor (otelconnect) that adopts as much of each caller's trace context as classify grants it: all of it (TrustAll), its trace and parent span ids only (TrustIDs), or none — a new trace linked to the caller's (TrustNone). Pass it as observe.Deps.Trace so it runs outermost. opts are applied to every underlying interceptor (do not pass otelconnect.WithTrustRemote yourself). A nil classify trusts no one, which is otelconnect's default.

A TrustIDs request is sampled by the server's own head-sampling policy (OTEL_TRACES_SAMPLER / OTEL_TRACES_SAMPLER_ARG, as the SDK reads them), whatever the caller's sampled flag says.

func TrustRemoteFrom ¶ added in v1.0.0

func TrustRemoteFrom(trusted TrustPredicate, opts ...otelconnect.Option) (connect.Interceptor, error)

TrustRemoteFrom returns the server tracing interceptor (otelconnect) that continues the caller's whole trace context (TrustAll) when trusted reports the caller authenticated, and otherwise starts a new trace linked to the caller's. Pass it as observe.Deps.Trace so it runs outermost. opts are applied to both underlying interceptors (do not pass otelconnect.WithTrustRemote yourself). A nil trusted trusts no one, which is otelconnect's default. TrustRemoteBy is the three-level form.

func ValidEventName ¶ added in v1.0.0

func ValidEventName(name string) bool

ValidEventName reports whether name is a legal product event name: snake_case, starting with a letter, at most 64 characters.

func WithLogger ¶

func WithLogger(ctx context.Context, logger *slog.Logger) context.Context

WithLogger returns a copy of ctx carrying logger. The runtime (serverkit.Run, a cobra RunE, a worker fan-out) calls this once at the top of a request/command so downstream code can recover the request-scoped logger without threading it through every signature.

A nil logger is stored as-is; FromContext substitutes a usable default when it reads one back, so callers never have to nil-check.