slog dan log di Golang: Structured Logging di Go

slog dalam satu contoh

log/slog (Go 1.21) menulis record terstruktur: sebuah pesan, sebuah level, dan atribut key-value.

package main

import (
	"log/slog"
	"os"
)

func main() {
	opts := &slog.HandlerOptions{Level: slog.LevelDebug}
	logger := slog.New(slog.NewTextHandler(os.Stdout, opts))

	logger.Debug("cache lookup", "key", "user:42", "hit", false)
	logger.Info("user logged in", "user", "ada", "attempts", 1)
	logger.Warn("slow query", "table", "orders", "ms", 812)
	logger.Error("payment failed", "order", 1017, "err", "card declined")
}

Setiap baris keluar sebagai time=... level=INFO msg="user logged in" user=ada attempts=1. Karena setiap nilai adalah field tersendiri, log collector (Loki, Elasticsearch, CloudWatch, Datadog) bisa memfilter berdasarkan user=ada atau level=ERROR tanpa regular expression pada teks bebas.

Contoh di halaman ini menulis ke os.Stdout supaya output-nya tampil berurutan. Di service sungguhan, log biasanya dikirim ke os.Stderr, yang juga merupakan tujuan tulis logger default.

Level

Handler membuang record di bawah level minimumnya, dan minimum default-nya adalah Info. Itulah sebabnya slog.Debug(...) tidak mencetak apa pun sampai kamu mengonfigurasi handler dengan Level: slog.LevelDebug. Jarak antarnilai menyisakan ruang untuk level kustom seperti slog.Level(2).

Untuk mengubah level saat program berjalan (dari flag, endpoint admin, atau signal), taruh slog.LevelVar di opsi lalu panggil Set padanya nanti:

var level slog.LevelVar // zero value: Info
logger := slog.New(slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: &level}))
level.Set(slog.LevelDebug) // from now on, debug records are written

Teks atau JSON

slog.NewTextHandler menulis pasangan key=value, mudah dibaca di terminal. slog.NewJSONHandler menulis satu object JSON per baris, format yang diharapkan sebagian besar pipeline log. Pemanggilan logging-nya tetap sama; hanya handler-nya yang berubah.

package main

import (
	"errors"
	"log/slog"
	"os"
	"time"
)

func main() {
	// Drop the time attribute so the output is the same on every run.
	noTime := func(groups []string, a slog.Attr) slog.Attr {
		if a.Key == slog.TimeKey && len(groups) == 0 {
			return slog.Attr{}
		}
		return a
	}

	text := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime}))
	json := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime}))

	for _, l := range []*slog.Logger{text, json} {
		l.Info("request served",
			"method", "GET",
			"path", "/items/7",
			"status", 200,
			"duration", 42*time.Millisecond,
		)
		l.Error("request failed", "err", errors.New("db timeout"), "retry", true)
	}
}

Nilai mempertahankan tipenya: status berupa angka di output JSON dan retry berupa boolean, time.Duration tercetak sebagai 42ms di teks dan sebagai nanodetik di JSON, dan error mencetak pesannya. ReplaceAttr adalah hook untuk menulis ulang atau menghapus atribut, di sini dipakai untuk membuang timestamp, dan dalam praktiknya untuk mengganti nama key (msg menjadi message) atau menyamarkan nilai.

Atribut

Bentuk yang longgar tipenya menyelang-nyeling key dan nilai: "user", "ada", "attempts", 3. Bentuk ini singkat, dan punya satu kemungkinan gagal: jumlah argumen yang ganjil. Nilai yang tersisa dicatat dengan key !BADKEY. go vet bisa menangkapnya:

./main.go:14:2: call to slog.Info missing a final value

Untuk keamanan tipe dan alokasi yang sedikit lebih hemat, pakai constructor atribut, dan LogAttrs saat logging di jalur yang sering dieksekusi (hot path):

logger.Info("order placed",
	slog.Int("order_id", 1017),
	slog.String("currency", "EUR"),
	slog.Float64("total", 59.90),
	slog.Duration("took", elapsed),
)

logger.LogAttrs(ctx, slog.LevelInfo, "order placed", slog.Int("order_id", 1017))

Pakai satu konvensi penamaan key di seluruh codebase (user_id di mana-mana, bukan userID di satu package dan uid di package lain). Query di sistem log-mu bergantung pada hal itu.

With: logger yang membawa konteks

logger.With(attrs...) mengembalikan logger baru yang menambahkan atribut-atribut itu ke setiap record. Buat satu per request atau per job, dan setiap baris yang ditulisnya bisa dihubungkan satu sama lain:

package main

import (
	"log/slog"
	"os"
)

func handleRequest(base *slog.Logger, requestID, user string) {
	log := base.With("request_id", requestID, "user", user)

	log.Info("loading cart")
	log.Info("charging card", slog.Group("payment", "amount", 25, "currency", "USD"))
	log.Warn("inventory low", "sku", "A-17", "left", 2)
}

func main() {
	noTime := func(groups []string, a slog.Attr) slog.Attr {
		if a.Key == slog.TimeKey && len(groups) == 0 {
			return slog.Attr{}
		}
		return a
	}
	base := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime}))
	base = base.With("service", "checkout", "version", "1.4.2")

	handleRequest(base, "req-81", "ada")
}

Setiap baris membawa service, version, request_id, dan user tanpa perlu diulang di setiap pemanggilan. slog.Group menyusun atribut secara bersarang, yang ditulis handler JSON sebagai object bersarang ("payment":{"amount":25,"currency":"USD"}) dan oleh handler teks sebagai key bertitik (payment.amount=25). logger.WithGroup("db") menaruh setiap atribut berikutnya dari logger itu di bawah sebuah group.

Teruskan logger berlingkup request ke bawah sebagai parameter atau field struct. Menyimpannya di context.Context memang bisa, tapi menyembunyikan dependensinya; method InfoContext(ctx, ...) milik slog meneruskan context ke handler, yang bisa dipakai handler kustom untuk mengambil trace ID.

Menyembunyikan rahasia dengan LogValuer

Sebuah tipe bisa mengatur cara ia dicatat di log dengan mengimplementasikan slog.LogValuer. Cara ini menjauhkan password dan token dari log, siapa pun yang mencatat nilainya:

package main

import (
	"log/slog"
	"os"
)

type Token string

func (Token) LogValue() slog.Value {
	return slog.StringValue("REDACTED")
}

type User struct {
	ID    int
	Email string
	Token Token
}

func (u User) LogValue() slog.Value {
	return slog.GroupValue(
		slog.Int("id", u.ID),
		slog.String("email", u.Email),
	)
}

func main() {
	noTime := func(groups []string, a slog.Attr) slog.Attr {
		if a.Key == slog.TimeKey && len(groups) == 0 {
			return slog.Attr{}
		}
		return a
	}
	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime}))

	u := User{ID: 7, Email: "ada@example.com", Token: "s3cr3t"}
	logger.Info("login", "user", u)
	logger.Info("token refresh", "token", u.Token)
}

User hanya mencatat ID dan email-nya, dan Token yang dicatat sendirian mencetak REDACTED. Handler memanggil LogValue hanya saat record benar-benar ditulis, jadi cara ini juga cocok untuk nilai yang mahal dihitung.

Package log klasik

log sudah ada sebelum slog dan masih cocok untuk program kecil dan script. Package ini menulis baris ke standard error dengan prefix tanggal dan waktu:

package main

import (
	"log"
	"os"
)

func main() {
	log.SetOutput(os.Stdout) // default is os.Stderr
	log.SetFlags(0)          // no timestamp, so the output is the same every run
	log.Println("plain line")
	log.Printf("processed %d files", 12)

	log.SetFlags(log.Lshortfile)
	log.SetPrefix("[worker] ")
	log.Println("with file:line and a prefix")

	errLog := log.New(os.Stdout, "ERROR ", log.Lmsgprefix)
	errLog.Println("a separate logger with its own prefix")
}

Tiga kelompok fungsi menghentikan program atau memicu panic, dan perbedaannya penting:

• log.Fatal, log.Fatalf, log.Fatalln mencetak lalu memanggil os.Exit(1). Pemanggilan yang di-defer tidak dijalankan. Pakai di main untuk kegagalan saat startup, jangan pernah di kode library atau request handler.
• log.Panic dan teman-temannya mencetak lalu memicu panic, jadi pemanggilan defer tetap berjalan dan panic-nya bisa di-recover.
• Semua fungsi lainnya hanya menulis satu baris.

Untuk menulis log ke file, buka file-nya lalu berikan ke log.New atau log.SetOutput; io.MultiWriter(os.Stderr, f) menulis ke keduanya.

log dan slog bersamaan

slog.SetDefault(logger) menjadikan logger sebagai default untuk fungsi tingkat atas slog.Info, sekaligus mengalirkan output package log lewat logger itu. Pemanggilan log.Printf yang sudah ada di kodemu atau di dependensi lalu keluar sebagai record terstruktur di level Info:

slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stderr, nil)))
log.Printf("legacy message") // {"time":"...","level":"INFO","msg":"legacy message"}

Sebelum SetDefault, logger slog default menulis lewat package log, itulah sebabnya slog.Info("hi") saja mencetak 2026/09/23 14:30:00 INFO hi.

Aturan praktis

• Catat error di log atau kembalikan, jangan keduanya. Fungsi yang mencatat error lalu juga mengembalikannya membuat kegagalan yang sama tercatat di setiap level call stack. Kembalikan error ke atas beserta konteksnya, dan catat sekali di tempat error itu ditangani.
• Taruh data yang berubah-ubah di atribut, bukan di pesan. logger.Info("user created", "user_id", id) mudah dikelompokkan di sistem log; logger.Info(fmt.Sprintf("user %d created", id)) menghasilkan pesan berbeda untuk setiap user.
• Jangan pernah mencatat rahasia atau body request lengkap. Pakai LogValuer atau ReplaceAttr untuk menyamarkannya.
• Pakai JSON di production, teks saat development. Pilih handler saat startup dari flag atau environment variable.
• Pilih level dengan sengaja. Kalau semuanya dicatat di level Error, peringatan untuk error jadi tidak berarti.