fmt.Println("here")
fmt.Println("here 2")
fmt.Println("HEREEEEEEE")
fmt.Println("why")

package main

import (
    "os"

    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
)

func main() {
    // AtomicLevel: flip the log level at runtime (e.g. from a /debug endpoint).
    atom := zap.NewAtomicLevelAt(zap.InfoLevel)

    logger := zap.New(zapcore.NewCore(
        zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
        zapcore.AddSync(os.Stderr),
        atom,
    ), zap.AddCaller())
    defer logger.Sync()

    // Typed-field API — zero-allocation fast path.
    logger.Info("typed fields are fast",
        zap.String("user_id", "u_42"),
        zap.Int("attempt", 3),
    )

    // Named + With: hierarchical name and bound fields on every line.
    reqLog := logger.Named("http").With(zap.String("request_id", "req_abc123"))
    reqLog.Info("handling request")

    logger.Debug("you will NOT see this — level is INFO")
    atom.SetLevel(zap.DebugLevel)
    logger.Debug("now you see me — atomic level flipped to DEBUG")
}

package main

import (
    "errors"
    "net"
    "os"
    "time"

    "github.com/rs/zerolog"
)

// Hooks fire on every log line — perfect for tagging alerts, adding trace IDs, etc.
type alertHook struct{}

func (alertHook) Run(e *zerolog.Event, level zerolog.Level, _ string) {
    if level >= zerolog.ErrorLevel {
        e.Bool("alert", true)
    }
}

func main() {
    // ConsoleWriter: colored, human-readable output for local dev.
    console := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.Kitchen}
    pretty := zerolog.New(console).With().Timestamp().Caller().Logger()
    pretty.Warn().Str("user", "alice").Int("attempts", 3).Msg("retrying")

    // JSON for production — sub-logger with bound fields + hook.
    jsonLog := zerolog.New(os.Stdout).
        With().Timestamp().Str("service", "api").
        Logger().Hook(alertHook{})

    jsonLog.Error().
        Err(errors.New("db connection refused")).
        IPAddr("peer", net.ParseIP("10.0.0.1")).
        Dur("elapsed", 142*time.Millisecond).
        Msg("write failed")

    // Sampling: keep 1-in-N lines on a hot path to spare disk.
    sampled := jsonLog.Sample(&zerolog.BasicSampler{N: 10})
    for i := 0; i < 25; i++ {
        sampled.Info().Int("i", i).Msg("hot loop log")
    }
}

package main

import (
    "errors"
    "os"

    "github.com/sirupsen/logrus"
)

// A Hook fires on a configured set of levels — the logrus way to ship
// errors to Sentry, post warnings to Slack, etc.
type AlertHook struct{}

func (h *AlertHook) Levels() []logrus.Level {
    return []logrus.Level{
        logrus.WarnLevel, logrus.ErrorLevel, logrus.FatalLevel, logrus.PanicLevel,
    }
}

func (h *AlertHook) Fire(entry *logrus.Entry) error {
    _, _ = os.Stderr.WriteString("[ALERT] " + entry.Level.String() + ": " + entry.Message + "\n")
    return nil
}

func main() {
    logrus.SetFormatter(&logrus.JSONFormatter{})
    logrus.AddHook(&AlertHook{})

    // Reusable Entry: bind common fields once, log many times.
    req := logrus.WithFields(logrus.Fields{
        "request_id": "req_abc123",
        "path":       "/api/widgets",
    })
    req.Info("handling request")
    req.WithError(errors.New("timeout")).Error("downstream call failed")
}

package main

import (
    "errors"
    "fmt"
    "log"
    "os"

    "github.com/go-logr/logr"
    "github.com/go-logr/logr/funcr"
    "github.com/go-logr/zapr"
    "go.uber.org/zap"
)

type service struct {
    log logr.Logger
}

func (s *service) handle(id string) {
    s.log.Info("handling", "id", id)
    s.log.V(1).Info("verbose: extra detail", "id", id)
    s.log.V(2).Info("trace: noisy debug", "id", id)
    s.log.Error(errors.New("database busy"), "handle failed", "id", id)
}

// The point of logr: this code doesn't know or care which logger backs it.
func main() {
    var logger logr.Logger

    switch os.Getenv("LOGR_BACKEND") {
    case "funcr":
        logger = funcr.New(func(prefix, args string) {
            fmt.Println(prefix, args)
        }, funcr.Options{Verbosity: 1})
    default:
        zapLog, err := zap.NewProduction()
        if err != nil {
            log.Fatal(err)
        }
        defer zapLog.Sync()
        logger = zapr.NewLogger(zapLog)
    }

    svc := &service{log: logger.WithName("widgets").WithValues("tenant", "acme")}
    svc.handle("w_1")
}

package main

import (
    "fmt"
    "os"

    "github.com/op/go-logging"
)

var (
    apiLog = logging.MustGetLogger("api")
    dbLog  = logging.MustGetLogger("db")
)

func main() {
    // Backend 1: colorized stderr.
    stderr := logging.NewLogBackend(os.Stderr, "", 0)
    stderrFmt := logging.NewBackendFormatter(stderr, logging.MustStringFormatter(
        `%{color}%{time:15:04:05.000} %{module} ▶ %{level:.4s} %{id:03x}%{color:reset} %{message}`,
    ))
    stderrLeveled := logging.AddModuleLevel(stderrFmt)
    stderrLeveled.SetLevel(logging.INFO, "")    // default for all modules
    stderrLeveled.SetLevel(logging.DEBUG, "db") // chattier for the db module

    // Backend 2: plain file output.
    f, _ := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0664)
    defer f.Close()
    fileFmt := logging.NewBackendFormatter(
        logging.NewLogBackend(f, "", 0),
        logging.MustStringFormatter(`%{time:2006-01-02T15:04:05Z07:00} %{module} %{level:.4s} %{message}`),
    )

    // Backend 3: memory backend — keeps the last N records. Great for tests.
    mem := logging.NewMemoryBackend(8)

    logging.SetBackend(stderrLeveled, fileFmt, mem)

    apiLog.Info("server started")
    dbLog.Debug("query: SELECT * FROM users") // only visible because db is DEBUG
    apiLog.Critical("out of disk")

    // Inspect the in-memory backend — assert on this in tests.
    for node := mem.Head(); node != nil; node = node.Next() {
        r := node.Record
        fmt.Fprintf(os.Stderr, "[mem] %s/%s: %s\n", r.Module, r.Level, r.Message())
    }
}