slog-context

This workflow allows you to use standard slog methods (like slog.InfoContext) while automatically injecting attributes from the context.Context into the log lines. This is ideal when you are using the default package-level logger but passing a context around.

Append and Prepend

Use slogctx.Prepend(ctx, ...) to add attributes to the start of log lines, or slogctx.Append(ctx, ...) to add them to the end. Both accept a mix of slog.Attr and key-value pairs.

Custom Context Value Extractor

You can define custom logic to extract values from a context using the AttrExtractor type. Register these in slogctx.HandlerOptions under Prependers or Appenders.

OpenTelemetry TraceID/SpanID Extractor

To include OTEL tracing information, install the sub-module: go get github.com/veqryn/slog-context/otel Then use slogotel.ExtractTraceSpanID in your HandlerOptions.

HTTP Middleware and Extractor

For web servers, use the sloghttp package. The sloghttp.AttrCollection middleware allows you to collect attributes (like request IDs) that will be available to all log calls within that request's context.

// Example: Custom Extractor
type ctxKey struct{}

func customExtractor(ctx context.Context, _ time.Time, _ slog.Level, _ string) []slog.Attr {
	if v, ok := ctx.Value(ctxKey{}).(string); ok {
		return []slog.Attr{slog.String("my-key", v)}
	}
	return nil
}

func main() {
	h := slogctx.NewHandler(
		slog.NewJSONHandler(os.Stdout, nil),
		&slogctx.HandlerOptions{
			Prependers: []slogctx.AttrExtractor{slogctx.ExtractPrepended},
			Appenders: []slogctx.AttrExtractor{
				slogctx.ExtractAppended,
				customExtractor,
			},
		},
	)
	slog.SetDefault(slog.New(h))
}

The Attributes Extracted from Context Workflow allows you to attach attributes to a context.Context and have them automatically included in log lines, even if a specific logger isn't passed through the call stack.

This is achieved using a custom Handler that uses Prepend and Append logic. Instead of storing a logger in the context, the attributes themselves are stored in the context, and the Handler picks them up whenever a log record is written.

Key components include:

• HandlerOptions and AttrExtractor types: Used to define how custom values are pulled from a context.
• slogotel.ExtractTraceSpanID: An optional extractor that automatically adds OpenTelemetry TraceID and SpanID to log records, including error annotation for error-level logs.
• sloghttp.ExtractAttrCollection: An optional extractor that automatically adds attributes added via sloghttp.With after the sloghttp.AttrCollection middleware.

This workflow involves storing a *slog.Logger instance directly inside a context.Context. This allows you to add attributes and groups to the logger while keeping the logger scoped to the context's lifecycle. It eliminates the need to pass a logger as an explicit argument to every function, as you can simply pass the context.

Key operations:

• Initialize: Use slogctx.NewCtx(ctx, logger) to store a logger in a context.
• Retrieve: Use slogctx.FromCtx(ctx) to get the logger back out for manual use.
• Modify Context Logger: Use slogctx.With(ctx, ...) to add attributes or slogctx.WithGroup(ctx, ...) to create a group on the logger within the context.
• Log via Context: Use slogctx.Error(ctx, ...) (or other level wrappers like Info, Warn, Debug) to log using the logger contained in the context. These wrappers support slog.Attr and key-value pairs.

package main

import (
	"context"
	"errors"
	"log/slog"
	"os"

	slogctx "github.com/veqryn/slog-context"
)

func main() {
	h := slogctx.NewHandler(slog.NewJSONHandler(os.Stdout, nil), nil)
	slog.SetDefault(slog.New(h))

	// Store the logger inside the context
	ctx := slogctx.NewCtx(context.Background(), slog.Default())

	// Get the logger back out for manual usage
	log := slogctx.FromCtx(ctx)
	log.Warn("warning")

	// Add attributes directly to the logger in the context
	ctx = slogctx.With(ctx, "rootKey", "rootValue")

	// Create a group directly on the logger in the context
	ctx = slogctx.WithGroup(ctx, "someGroup")

	// Add mix of slog.Attr and key-value pairs
	ctx = slogctx.With(ctx, slog.String("subKey", "subValue"), slog.Bool("someBool", true))

	err := errors.New("an error")

	// Access the logger in the context directly with wrappers
	slogctx.Error(ctx, "main message",
		slogctx.Err(err),
		slog.String("mainKey", "mainValue"))
}

The sloggrpc package provides interceptors for both Unary and Stream gRPC calls (Server and Client sides). These interceptors automatically log RPC metadata such as service name, method, role, and request/response payloads.

Server Interceptors:

• sloggrpc.SlogUnaryServerInterceptor(...)
• sloggrpc.SlogStreamServerInterceptor(...)

Client Interceptors:

• sloggrpc.SlogUnaryClientInterceptor(...)
• sloggrpc.SlogStreamClientInterceptor(...)

Configuration Options:

• sloggrpc.WithAppendToAttributes(option): Controls which attributes are added. Use sloggrpc.AppendToAttributesAll for full detail or sloggrpc.AppendToAttributesDefault for a slimmer version.
• sloggrpc.WithInterceptorFilter(filter): Use sloggrpc.InterceptorFilterIgnoreReflection to skip logging for reflection calls.
• sloggrpc.WithErrorToLevel(level): (Mentioned in code) Customize the log level for errors.
• sloggrpc.WithLogger(logger): (Mentioned in code) Provide a specific logger.

// Server Interceptor Example
grpcServer := grpc.NewServer(
	grpc.ChainUnaryInterceptor(sloggrpc.SlogUnaryServerInterceptor(
		sloggrpc.WithAppendToAttributes(sloggrpc.AppendToAttributesAll),
		sloggrpc.WithInterceptorFilter(sloggrpc.InterceptorFilterIgnoreReflection),
	))),
)