serverboot

func Fatal ¶

func Fatal(ctx context.Context, msg string, err error, additionalArgs ...any)

Fatal logs msg + err and exits with status 1. For startup-time fail-fast where there's no recovery path.

func InitLogger ¶

func InitLogger()

InitLogger sets the global slog logger to a JSON handler wrapped in contextlogging.NewHandler, writing to os.Stdout. Call once at process start.

func InitLoggerWithWriter ¶

func InitLoggerWithWriter(w io.Writer)

InitLoggerWithWriter is InitLogger with an explicit destination. Use it to share one synchronized writer between the runtime logger and a separate writer (e.g. ateom's actor-log forwarder) so their lines don't interleave.

func InitLogging ¶ added in v0.2.0

func InitLogging(ctx context.Context, opts LoggingOptions) (*sdklog.LoggerProvider, error)

InitLogging registers a global LoggerProvider for the records components emit through internal/actorevent, and sets whether those records also go to stdout (console).

It returns (nil, nil) when the exporter does not include otlp, and leaves the OTel global alone: emitting then costs one Enabled check. Guard the shutdown on a nil provider, unlike InitTracing which always returns one.

The processor batches. These records sit on the actor resume and suspend path, and exporting inside the emit call would put a blocking gRPC round trip there, serialized across every emitting goroutine, so an unreachable collector would surface as control-plane latency. The cost is that an ungraceful exit loses the records still queued, unless console also wrote them to stdout.

func InitMetrics ¶

func InitMetrics(ctx context.Context, serviceName string) (*sdkmetric.MeterProvider, error)

InitMetrics registers a global MeterProvider with both a Prometheus reader (exposed via StartMetricsServer's /metrics handler) and an OTLP periodic reader, the latter while OTEL_METRICS_EXPORTER selects otlp. The Prometheus reader registers on the default registry.

func InitMetricsBridged ¶ added in v0.4.0

func InitMetricsBridged(ctx context.Context, serviceName string, reg interface {
	promclient.Registerer
	promclient.Gatherer
}, wrapProducer func(sdkmetric.Producer) sdkmetric.Producer) (mp *sdkmetric.MeterProvider, servePull bool, err error)

InitMetricsBridged is for a binary whose scraped endpoint serves a registry it does not own (atecontroller: controller-runtime's), so every metric reaches the backend exactly once on whichever path is active. With the OTLP export, reg is bridged onto the push and the OTel instruments stay off it, since the bridge would otherwise push them a second time. With prometheus alone, nothing is pushed and the OTel instruments register on reg, so its endpoint serves both.

servePull reports whether OTEL_METRICS_EXPORTER leaves the scraped endpoint on, which the caller must then serve from reg: unset, prometheus, or a list with it. otlp and none turn it off, and with none no reader is installed.

wrapProducer, when non-nil, wraps the bridge producer on the OTLP path, for a rewrite the push backend needs but the scraped endpoint does not.

func InitMetricsPushOnlyVia ¶

func InitMetricsPushOnlyVia(ctx context.Context, serviceName string, conn *grpc.ClientConn) (*sdkmetric.MeterProvider, error)

InitMetricsPushOnlyVia is InitMetrics without the Prometheus reader, for a binary that runs no metrics HTTP server of its own (ateom): a pull reader would collect into a registry nothing serves. conn is the metrics counterpart of TracingOptions.ExporterConn: ateom passes atelet's relay socket (internal/otlprelay) so the worker pod needs no network path of its own; a nil conn keeps the direct dial to OTEL_EXPORTER_OTLP_ENDPOINT.

The caller owns the connection: the meter provider's Shutdown does not close a connection it did not create.

Calling this at all marks the component relay-capable, so its metrics carry the relay attribute (see relayAttrs) either way — "relay" with a conn, "direct" without one. It is the metrics counterpart of TracingOptions.RelayCapable, implied rather than a parameter because only a caller that has a relay to pass reaches for this function in the first place.

func InitTracing ¶

func InitTracing(ctx context.Context, opts TracingOptions) (*sdktrace.TracerProvider, error)

InitTracing registers a global TracerProvider with the given options and the TraceContext text-map propagator.

func SetLogLevel ¶

func SetLogLevel(level string) error

SetLogLevel sets the minimum level of the serverboot loggers from a flag value: "debug", "info", "warn", or "error" (case-insensitive). Empty means unset and leaves the current level unchanged, so configs that never populate the field keep the default.

func ShutdownProvider ¶

func ShutdownProvider(name string, shutdown func(context.Context) error)

ShutdownProvider invokes the OTel provider's Shutdown and logs any error. Designed to be deferred from main():

defer serverboot.ShutdownProvider("TracerProvider", tp.Shutdown)

func StartHealthServer ¶ added in v0.5.0

func StartHealthServer(ctx context.Context, addr string, readiness *Readiness)

StartHealthServer runs an HTTP server exposing /readyz and /healthz for the kubelet probes. /readyz returns 200 while readiness is Ready and every check passes, and 503 after MarkNotReady or while a check fails. /healthz always returns 200, so liveness keeps succeeding while a draining server fails readiness. Blocks until the server stops; designed to be `go`-launched. A serve failure exits the process: a pod whose probes can never succeed never turns Ready, so dying loudly lets the kubelet restart it instead of leaving a pod that looks alive but never gets work.

func StartMetricsServer ¶

func StartMetricsServer(ctx context.Context, addr string)

StartMetricsServer runs an HTTP server exposing only /metrics (Prometheus). Blocks until the server stops; designed to be `go`-launched. The kubelet probes use StartHealthServer, so a change to the metrics endpoint does not change the health checks. A serve failure exits the process: the probes no longer report a metrics server that cannot bind, so without the exit the only sign of the failure is one log line.