Persona: You are a Go logging architect. You design log pipelines where every record flows through the right handlers — sampling drops noise early, formatters strip PII before records leave the process, and routers send errors to Sentry while info goes to Loki.

samber/slog-**** — Structured Logging Pipeline for Go

20+ composable

slog.Handler

slog.Handler

Official resources:

• github.com/samber/slog-multi — handler composition
• github.com/samber/slog-sampling — throughput control
• github.com/samber/slog-formatter — attribute transformation

This skill is not exhaustive. Please refer to library documentation and code examples for more informations. Context7 can help as a discoverability platform.

The Pipeline Model

Every samber/slog pipeline follows a canonical ordering. Records flow left to right — place sampling first to drop early and avoid wasting CPU on records that never reach a sink.

record → [Sampling] → [Pipe: trace/PII] → [Router] → [Sinks]

Order matters: sampling before formatting saves CPU. Formatting before routing ensures all sinks receive clean attributes. Reversing this wastes work on records that get dropped.

Core Libraries

slog-multi

Fanout

Router

FirstMatch

Failover

Pool

Pipe

slog-sampling

UniformSamplingOption

ThresholdSamplingOption

AbsoluteSamplingOption

CustomSamplingOption

slog-formatter

PIIFormatter

ErrorFormatter

FormatByType[T]

FormatByKey

FlattenFormatterMiddleware

slog-multi — Handler Composition

Six composition patterns, each for a different routing need:

Fanout(handlers...)

Router().Add(h, predicate).Handler()

Router().Add(...).FirstMatch().Handler()

Failover()(handlers...)

Pool()(handlers...)

Pipe(middlewares...).Handler(sink)

// Route errors to Sentry, all logs to stdout
logger := slog.New(
    slogmulti.Router().
        Add(sentryHandler, slogmulti.LevelIs(slog.LevelError)).
        Add(slog.NewJSONHandler(os.Stdout, nil)).
        Handler(),
)

Built-in predicates:

LevelIs

LevelIsNot

MessageIs

MessageIsNot

MessageContains

MessageNotContains

AttrValueIs

AttrKindIs

For full code examples of every pattern, see Pipeline Patterns.

slog-sampling — Throughput Control

Sampling MUST be the outermost handler in the pipeline — placing it after formatting wastes CPU on records that get dropped.

// Threshold: log first 10 per 5s, then 10% — errors always pass through via Router
logger := slog.New(
    slogmulti.
        Pipe(slogsampling.ThresholdSamplingOption{
            Tick: 5 * time.Second, Threshold: 10, Rate: 0.1,
        }.NewMiddleware()).
        Handler(innerHandler),
)

Matchers group similar records for deduplication:

MatchByLevel()

MatchByMessage()

MatchByLevelAndMessage()

MatchBySource()

MatchByAttribute(groups, key)

For strategy comparison and configuration details, see Sampling Strategies.

slog-formatter — Attribute Transformation

Apply as a

Pipe

logger := slog.New(
    slogmulti.Pipe(slogformatter.NewFormatterMiddleware(
        slogformatter.PIIFormatter("user"),          // mask PII fields
        slogformatter.ErrorFormatter("error"),       // structured error info
        slogformatter.IPAddressFormatter("client"),  // mask IP addresses
    )).Handler(slog.NewJSONHandler(os.Stdout, nil)),
)

Key formatters:

PIIFormatter

ErrorFormatter

TimeFormatter

UnixTimestampFormatter

IPAddressFormatter

HTTPRequestFormatter

HTTPResponseFormatter

FormatByType[T]

FormatByKey

FormatByKind

FormatByGroup

FormatByGroupKey

FlattenFormatterMiddleware

HTTP Middlewares

Consistent pattern across frameworks:

router.Use(slogXXX.New(logger))

Available:

slog-gin

slog-echo

slog-fiber

slog-chi

slog-http

All share a

Config

DefaultLevel

ClientErrorLevel

ServerErrorLevel

WithRequestBody

WithResponseBody

WithUserAgent

WithRequestID

WithTraceID

WithSpanID

Filters

// Gin with filters — skip health checks
router.Use(sloggin.NewWithConfig(logger, sloggin.Config{
    DefaultLevel:     slog.LevelInfo,
    ClientErrorLevel: slog.LevelWarn,
    ServerErrorLevel: slog.LevelError,
    WithRequestBody:  true,
    Filters: []sloggin.Filter{
        sloggin.IgnorePath("/health", "/metrics"),
    },
}))

For framework-specific setup, see HTTP Middlewares.

Backend Sinks

All follow the

Option{}.NewXxxHandler()

slog-datadog

slog-sentry

slog-loki

slog-graylog

slog-kafka

slog-fluentd

slog-logstash

slog-nats

slog-slack

slog-telegram

slog-webhook

slog-parquet

slog-zap

slog-zerolog

slog-logrus

Batch handlers require graceful shutdown —

slog-datadog

slog-loki

slog-kafka

slog-parquet

handler.Stop(ctx)

lokiClient.Stop()

writer.Close()

For configuration examples and shutdown patterns, see Backend Handlers.

Common Mistakes

Pool()

defer handler.Stop(ctx)

defer lokiClient.Stop()

defer writer.Close()

AttrFromContext

slog-gin

echo

fiber

chi

Pipe

Pipe()

Performance Warnings

• Fanout latency = sum of all handler latencies (sequential). With 5 handlers at 10ms each, every log call costs 50ms. Use

  Pool()

  to reduce to max(latencies)
• Pipe middleware adds per-record function call overhead — keep chains short (2-4 middlewares)
• slog-formatter processes attributes sequentially — many formatters compound. For hot-path attribute formatting, prefer implementing

  slog.LogValuer

  on your types instead
• Benchmark your pipeline with

  go test -bench

  before production deployment

Diagnose: measure per-record allocation and latency of your pipeline and identify which handler in the chain allocates most.

Best Practices

1. Sample first, format second, route last — this canonical ordering minimizes wasted work and ensures all sinks see clean data
2. Use Pipe for cross-cutting concerns — trace ID injection and PII scrubbing belong in middleware, not per-handler logic
3. Test pipelines with

   slogmulti.NewHandleInlineHandler

   — assert on records reaching each stage without real sinks
4. Use

   AttrFromContext

   to propagate request-scoped attributes from HTTP middleware to all handlers
5. Prefer Router over Fanout when handlers need different record subsets — Router evaluates predicates and skips non-matching handlers

Cross-References

• → See

  samber/cc-skills-golang@golang-observability

  skill for slog fundamentals (levels, context, handler setup, migration)
• → See

  samber/cc-skills-golang@golang-error-handling

  skill for the log-or-return rule
• → See

  samber/cc-skills-golang@golang-security

  skill for PII handling in logs
• → See

  samber/cc-skills-golang@golang-samber-oops

  skill for structured error context with

  samber/oops

If you encounter a bug or unexpected behavior in any samber/slog-* package, open an issue at the relevant repository (e.g., slog-multi/issues, slog-sampling/issues).