(refactor): prepare breaking v2 API

- rename package to sneklog and move module to /v2
- replace text output flags with writer formatters
- remove external color dependencies
- update migration notes and coverage

.gitea/workflows/go-lint.yaml

@@ -0,0 +1,12 @@
+name: Golang lint
+run-name: Linting code
+on: [push]
+
+jobs:
+  lint:
+    runs-on: go-latest
+    steps:
+      - name: Checkout repository code
+        uses: actions/checkout@v6
+      - name: Run golangci-lint
+        run: golangci-lint run

.gitignore

@@ -1,3 +1,5 @@
 .idea/
+.vscode/
+.codex
 test/
 *.log

README.md

@@ -1,2 +1,158 @@
-# ScuroLogger (slog)
+# SNekLog (ScuroNeko Logger)
 
+Small structured logger for Go with text and JSON output, multiple writers, and optional traceback metadata.
+
+Russian version: [README_ru.md](README_ru.md)
+
+## Features
+
+- Fan out the same record to multiple destinations.
+- Text and JSON writers.
+- `stdout`, files, and arbitrary external `io.Writer` values.
+- Optional timestamps for text output.
+- Compact traceback metadata for text writers and full traceback slices for JSON.
+- Message replacement for masking secrets or normalizing output.
+- Explicit ownership rules for writer closing.
+
+## Installation
+
+```bash
+go get git.scuroneko.dev/scuroneko/slog/v2
+```
+
+## Quick start
+
+```go
+package main
+
+import (
+	"log"
+
+	"git.scuroneko.dev/scuroneko/slog/v2"
+)
+
+func main() {
+	logger := sneklog.CreateLogger().
+		Prefix("API").
+		Level(sneklog.DEBUG).
+		AddReplacer("SOME_SECRET", "<redacted>")
+
+	text := logger.CreateTextStdoutWriter()
+	jsonFile, err := logger.CreateJsonFileWriter("logs/app.json")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	logger.AddWriters(text, jsonFile)
+
+	logger.Infoln("service started")
+	logger.Warnln("cache miss")
+	logger.Errorln("request failed")
+	logger.Debugln("debug details")
+	logger.Infoln("token", "SOME_SECRET")
+
+	if err := logger.Close(); err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+## Defaults
+
+`CreateLogger()` starts with:
+
+- `Prefix("LOG")`
+- `Level(sneklog.FATAL)`
+- `JsonPretty(false)`
+- text formatter: `sneklog.DefaultTextFormatter`
+- JSON formatter: `sneklog.DefaultJsonFormatter`
+
+Important: with the current level ordering, `Level(sneklog.FATAL)` allows `INFO`, `WARN`, `ERROR`, and `FATAL`, but not `DEBUG`. Use `Level(sneklog.DEBUG)` to enable every level.
+
+## Writers and ownership
+
+`Logger.Close()` only closes writers created by the logger itself:
+
+- `CreateTextFileWriter(...)`
+- `CreateJsonFileWriter(...)`
+
+The following writers remain owned by the caller and are not closed by `Logger.Close()`:
+
+- `CreateTextWriter(existingWriter)`
+- `CreateJsonWriter(existingWriter)`
+- `CreateTextStdoutWriter()`
+- `CreateJsonStdoutWriter()`
+
+This makes it safe to plug in `bytes.Buffer`, network writers, and other externally managed resources.
+
+## Output formats
+
+Text writers render records like:
+
+```text
+2026-03-17T14:05:09+03:00 info API: service started
+```
+
+Use `SetFormatter` on a writer to customize timestamps, traceback fields, colors, and message layout.
+
+JSON writers emit objects with this shape:
+
+```json
+{
+  "time": "2026-03-17T14:05:09.123456789+03:00",
+  "level": "info",
+  "prefix": "API",
+  "message": "service started",
+  "traceback": [
+    {
+      "method": "main",
+      "filename": "main.go",
+      "line": 27,
+      "signature": "main.main",
+      "fullPath": "/path/to/main.go"
+    }
+  ]
+}
+```
+
+When `JsonPretty(true)` is enabled, JSON is indented.
+
+## Message replacement
+
+`AddReplacer(old, new)` replaces matching text in every message before the
+record reaches any writer. Replacement rules are applied in the order they are
+added.
+
+```go
+logger := sneklog.CreateLogger().
+	Level(sneklog.DEBUG).
+	AddReplacer("SOME_SECRET", "<redacted>").
+	AddReplacer("user@example.com", "<email>")
+
+logger.Infoln("login token:", "SOME_SECRET")
+```
+
+This writes `<redacted>` instead of `SOME_SECRET` in both text and JSON output.
+An empty `old` value is ignored.
+
+## API summary
+
+- `Info`, `Warn`, `Error`, `Debug`, and `Fatal` accept a list of values.
+- `Infof`, `Warnf`, `Errorf`, `Debugf`, and `Fatalf` use `fmt.Sprintf`.
+- The `*ln` methods preserve newline semantics, which is useful for `stdout`, Docker, and line-based collectors.
+- `Fatal`, `Fatalf`, and `Fatalln` call `os.Exit(1)` after writing the message.
+- `AddReplacer` masks or rewrites message text before records are sent to writers.
+
+## Traceback behavior
+
+- Text writers use the nearest user stack frame.
+- JSON writers receive the full traceback slice.
+- Internal `slog` frames and `runtime` frames are filtered out.
+
+## Repository example
+
+See [examples/main.go](examples/main.go).
+
+## License
+
+This project is licensed under GNU GPLv3. See [LICENSE](LICENSE).

README_ru.md

@@ -0,0 +1,157 @@
+# SNekLog (ScuroNeko Logger)
+
+Небольшой структурированный логгер для Go с текстовым и JSON-выводом, несколькими writer'ами и настраиваемыми traceback-метаданными.
+
+English version: [README.md](README.md)
+
+## Возможности
+
+- Одновременная запись в несколько destinations.
+- Текстовый и JSON-форматы.
+- `stdout`, файлы и любые внешние `io.Writer`.
+- Опциональные timestamp'ы для текстового вывода.
+- Компактный traceback для текстовых writer'ов и полный traceback для JSON.
+- Замена текста в сообщениях для маскирования секретов или нормализации вывода.
+- Явные правила владения writer'ами при `Close()`.
+
+## Установка
+
+```bash
+go get git.scuroneko.dev/scuroneko/slog/v2
+```
+
+## Быстрый старт
+
+```go
+package main
+
+import (
+	"log"
+
+	"git.scuroneko.dev/scuroneko/slog/v2"
+)
+
+func main() {
+	logger := sneklog.CreateLogger().
+		Prefix("API").
+		Level(sneklog.DEBUG).
+		AddReplacer("SOME_SECRET", "<redacted>")
+
+	text := logger.CreateTextStdoutWriter()
+	jsonFile, err := logger.CreateJsonFileWriter("logs/app.json")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	logger.AddWriters(text, jsonFile)
+
+	logger.Infoln("service started")
+	logger.Warnln("cache miss")
+	logger.Errorln("request failed")
+	logger.Debugln("debug details")
+	logger.Infoln("token", "SOME_SECRET")
+
+	if err := logger.Close(); err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+## Значения по умолчанию
+
+`CreateLogger()` создает логгер со следующими настройками:
+
+- `Prefix("LOG")`
+- `Level(sneklog.FATAL)`
+- `JsonPretty(false)`
+- текстовый formatter: `sneklog.DefaultTextFormatter`
+- JSON formatter: `sneklog.DefaultJsonFormatter`
+
+Важно: в текущей модели уровней `Level(sneklog.FATAL)` пропускает `INFO`, `WARN`, `ERROR` и `FATAL`, но не `DEBUG`. Чтобы включить все сообщения, используйте `Level(sneklog.DEBUG)`.
+
+## Writer'ы и владение
+
+`Logger.Close()` закрывает только writer'ы, которые логгер создал сам:
+
+- `CreateTextFileWriter(...)`
+- `CreateJsonFileWriter(...)`
+
+Внешние writer'ы не закрываются:
+
+- `CreateTextWriter(existingWriter)`
+- `CreateJsonWriter(existingWriter)`
+- `CreateTextStdoutWriter()`
+- `CreateJsonStdoutWriter()`
+
+Это позволяет безопасно подключать `bytes.Buffer`, сетевые writer'ы и другие уже управляемые ресурсы.
+
+## Форматы вывода
+
+Текстовый writer формирует записи вида:
+
+```text
+2026-03-17T14:05:09+03:00 info API: service started
+```
+
+Используйте `SetFormatter` у writer'а, чтобы настроить timestamp'ы, traceback-поля, цвета и шаблон сообщения.
+
+JSON writer записывает объект со следующими полями:
+
+```json
+{
+  "time": "2026-03-17T14:05:09.123456789+03:00",
+  "level": "info",
+  "prefix": "API",
+  "message": "service started",
+  "traceback": [
+    {
+      "method": "main",
+      "filename": "main.go",
+      "line": 27,
+      "signature": "main.main",
+      "fullPath": "/path/to/main.go"
+    }
+  ]
+}
+```
+
+Если включен `JsonPretty(true)`, JSON выводится с отступами.
+
+## Замена сообщений
+
+`AddReplacer(old, new)` заменяет найденный текст в каждом сообщении до того,
+как запись попадет в writer'ы. Правила замены применяются в порядке добавления.
+
+```go
+logger := sneklog.CreateLogger().
+	Level(sneklog.DEBUG).
+	AddReplacer("SOME_SECRET", "<redacted>").
+	AddReplacer("user@example.com", "<email>")
+
+logger.Infoln("login token:", "SOME_SECRET")
+```
+
+В текстовом и JSON-выводе вместо `SOME_SECRET` будет записано `<redacted>`.
+Пустое значение `old` игнорируется.
+
+## API кратко
+
+- `Info`, `Warn`, `Error`, `Debug`, `Fatal` принимают список значений.
+- `Infof`, `Warnf`, `Errorf`, `Debugf`, `Fatalf` используют `fmt.Sprintf`.
+- Методы `*ln` добавляют семантику перевода строки, что удобно для `stdout`, Docker и line-based collectors.
+- `Fatal`, `Fatalf` и `Fatalln` вызывают `os.Exit(1)` после записи сообщения.
+- `AddReplacer` маскирует или переписывает текст сообщений перед отправкой в writer'ы.
+
+## Поведение traceback
+
+- Текстовые writer'ы используют ближайший пользовательский stack frame.
+- JSON writer'ы получают полный traceback.
+- Внутренние frame'ы `slog` и `runtime` фильтруются из traceback.
+
+## Пример из репозитория
+
+См. [examples/main.go](examples/main.go).
+
+## Лицензия
+
+Проект распространяется под GNU GPLv3. См. [LICENSE](LICENSE).

RELEASE_NOTES.md

@@ -0,0 +1,122 @@
+# v2.0.0
+
+## Highlights
+
+- Renamed the public Go package from `slog` to `sneklog` to avoid confusion with the standard library `log/slog` package.
+- Moved the module path to `git.scuroneko.dev/scuroneko/slog/v2` for Go module major-version compatibility.
+- Replaced fixed text writer settings with formatter-based output customization.
+- Added built-in ANSI color support and removed the external `github.com/fatih/color` dependency tree.
+- Formatters: a new way do display your logs!
+
+## Breaking Changes
+
+- Import paths must use the `/v2` module suffix:
+
+```go
+import sneklog "git.scuroneko.dev/scuroneko/slog/v2"
+```
+
+- Package references should use `sneklog` instead of `slog`.
+- Removed `Logger.PrintTime` and `Logger.PrintTraceback`; configure output through writer formatters instead.
+- Changed text writer constructors:
+  - `CreateTextWriter(w, printTraceback, printTime)` is now `CreateTextWriter(w)`.
+  - `CreateTextFileWriter(path, printTraceback, printTime)` is now `CreateTextFileWriter(path)`.
+  - `CreateTextStdoutWriter(printTraceback, printTime)` is now `CreateTextStdoutWriter()`.
+- Removed the old text formatting helpers: `BuildString`, `FormatTime`, `FormatTraceback`, and `FormatFullTraceback`.
+- JSON `time` values are now formatted through the configured formatter and stored as strings in `LoggerJsonMessage`.
+
+## Added
+
+- `Formatter` for configurable message layouts, timestamp layouts, traceback layouts, separators, and color behavior.
+- `DefaultTextFormatter` and `DefaultJsonFormatter` defaults for text and JSON writers.
+- `LoggerTextWriter.SetFormatter` and `LoggerJsonWriter.SetFormatter`.
+- Strftime-like timestamp format constants such as `RFC3339`, `Kitchen`, `DateTime`, `DateOnly`, and `TimeOnly`.
+- Built-in color types and helpers:
+  - `FgColor`, `BgColor`, and `Attribute`.
+  - `ColorStringBuilder`.
+  - Level color getters/setters on `LogLevel`.
+- Tests covering formatter defaults, empty traceback placeholders, literal `%` sequences in messages, color controls, and JSON newline semantics.
+
+## Changed
+
+- Text output defaults to `DefaultTextFormatter` instead of the old hard-coded string builder.
+- JSON output defaults to `DefaultJsonFormatter` and can now format the JSON `message` field through `Formatter`.
+- Newline semantics are normalized before text and JSON formatting, so trailing `\n` controls record termination without becoming part of the message.
+- Text color output is enabled by default only for stdout/stderr.
+- Example code now demonstrates custom formatters and color configuration.
+- Go dependencies were simplified by removing:
+  - `github.com/fatih/color`
+  - `github.com/mattn/go-colorable`
+  - `github.com/mattn/go-isatty`
+  - `golang.org/x/sys`
+
+## Fixed
+
+- `NewFormatter()` now returns a fresh copy instead of mutating `DefaultTextFormatter`.
+- `Formatter.FormatMessage` no longer panics when called with an empty traceback.
+- Placeholder-looking text inside log messages, such as `%L` or `%s`, is preserved literally.
+- `SetColorOutput(false)` disables color output.
+- `SetColorOnlyStdout(false)` allows color output for non-stdout writers.
+
+## Migration
+
+Before:
+
+```go
+import "git.scuroneko.dev/scuroneko/slog"
+
+logger := slog.CreateLogger().
+	Prefix("API").
+	Level(slog.DEBUG).
+	PrintTraceback(true)
+
+text := logger.CreateTextStdoutWriter()
+```
+
+After:
+
+```go
+import sneklog "git.scuroneko.dev/scuroneko/slog/v2"
+
+logger := sneklog.CreateLogger().
+	Prefix("API").
+	Level(sneklog.DEBUG)
+
+formatter := sneklog.NewFormatter().
+	SetFormat("%t [%L] %N: %m (%B)")
+
+text := logger.CreateTextStdoutWriter().
+	SetFormatter(formatter)
+```
+
+# v1.2.0
+
+## Highlights
+
+- Added message replacement with `Logger.AddReplacer(old, new)` for masking secrets or normalizing log output.
+- Preserved the existing `LoggerWriter.Print(...any)` contract, so custom writers do not need a signature update.
+- Improved JSON writer newline handling for messages that already end with `\n`.
+
+## Added
+
+- `Logger.AddReplacer(old, new)` appends a replacement rule that is applied before records are sent to writers.
+- README and package GoDoc now document message replacement and include usage examples.
+- Tests covering message type preservation for custom writers, JSON empty messages, and JSON trailing newline behavior.
+
+## Fixed
+
+- `LoggerJsonWriter.Print` no longer panics when called with no message arguments.
+- `LoggerJsonWriter.Print` now treats a trailing newline at the end of the last message as newline semantics and does not include that newline in the JSON `message` field.
+- Log messages keep their original argument types for custom writers when no replacement rules are configured.
+
+## Changed
+
+- Updated the example program to demonstrate `AddReplacer`.
+- Updated dependencies:
+  - `github.com/fatih/color` from `v1.18.0` to `v1.19.0`
+  - `github.com/mattn/go-isatty` from `v0.0.20` to `v0.0.21`
+  - `golang.org/x/sys` from `v0.42.0` to `v0.43.0`
+
+## Compatibility
+
+No breaking API changes are intended in this release. The public `LoggerWriter` interface continues to accept `messages ...any`.

colors.go

@@ -0,0 +1,181 @@
+package sneklog
+
+import (
+	"fmt"
+	"strings"
+)
+
+type FgColor uint8
+type BgColor uint8
+type Attribute uint8
+
+const (
+	Reset Attribute = iota
+	Bold
+	Faint
+	Italic
+	Underline
+	BlinkSlow
+	BlinkRapid
+	Invert
+	Conceal
+	CrossedOut
+)
+const (
+	DoubleUnderline Attribute = iota + 21 // Can be disable bold on some terminals
+	DisableBold
+	DisableItalic
+	DisableUnderline
+	DisableBlink
+	DisableInvert
+	DisableConceal
+	DisableCrossedOut
+)
+const (
+	FgBlack FgColor = iota + 30
+	FgRed
+	FgGreen
+	FgYellow
+	FgBlue
+	FgMagenta
+	FgCyan
+	FgWhite
+	FgDefault FgColor = 39
+)
+const (
+	BgBlack BgColor = iota + 40
+	BgRed
+	BgGreen
+	BgYellow
+	BgBlue
+	BgMagenta
+	BgCyan
+	BgWhite
+	BgDefault BgColor = 49
+)
+const (
+	FgHiBlack FgColor = iota + 90
+	FgHiRed
+	FgHiGreen
+	FgHiYellow
+	FgHiBlue
+	FgHiMagenta
+	FgHiCyan
+	FgHiWhite
+)
+const (
+	BgHiBlack BgColor = iota + 100
+	BgHiRed
+	BgHiGreen
+	BgHiYellow
+	BgHiBlue
+	BgHiMagenta
+	BgHiCyan
+	BgHiWhite
+)
+
+// This attributes rarely used and not supported by all terminals.
+const (
+	Border Attribute = iota + 51
+	Outline
+	Upperline
+	DisableBorderOutline
+	DisableUpperline
+)
+
+type ColorStringBuilder struct {
+	str string
+}
+
+func NewColorStringBuilder() *ColorStringBuilder {
+	return &ColorStringBuilder{str: ""}
+}
+func (builder *ColorStringBuilder) AddAttribute(attr Attribute) *ColorStringBuilder {
+	builder.str += attr.String()
+	return builder
+}
+func (builder *ColorStringBuilder) AddFgColor(color FgColor) *ColorStringBuilder {
+	if color == 0 {
+		return builder
+	}
+	builder.str += color.String()
+	return builder
+}
+func (builder *ColorStringBuilder) AddBgColor(color BgColor) *ColorStringBuilder {
+	if color == 0 {
+		return builder
+	}
+	builder.str += color.String()
+	return builder
+}
+func (builder *ColorStringBuilder) AddColor256Fg(color uint8) *ColorStringBuilder {
+	builder.str += color256Fg(color)
+	return builder
+}
+func (builder *ColorStringBuilder) AddColor256Bg(color uint8) *ColorStringBuilder {
+	builder.str += color256Bg(color)
+	return builder
+}
+func (builder *ColorStringBuilder) AddColorRgbFg(r, g, b uint8) *ColorStringBuilder {
+	builder.str += colorRgbFg(r, g, b)
+	return builder
+}
+func (builder *ColorStringBuilder) AddColorRgbBg(r, g, b uint8) *ColorStringBuilder {
+	builder.str += colorRgbBg(r, g, b)
+	return builder
+}
+func (builder *ColorStringBuilder) AddReset() *ColorStringBuilder {
+	builder.str += "\x1b[0m"
+	return builder
+}
+func (builder *ColorStringBuilder) AddText(text string) *ColorStringBuilder {
+	builder.str += text
+	return builder
+}
+func (builder *ColorStringBuilder) String() string {
+	if strings.Contains(builder.str, "\x1b[") && !strings.HasSuffix(builder.str, "\x1b[0m") {
+		builder.AddReset()
+	}
+	return builder.str
+}
+
+func (a Attribute) String() string {
+	return fmt.Sprintf("\x1b[%dm", a)
+}
+func (a Attribute) Uint8() uint8 {
+	return uint8(a)
+}
+func (a Attribute) Int() int {
+	return int(a)
+}
+func (c FgColor) String() string {
+	return fmt.Sprintf("\x1b[%dm", c)
+}
+func (c FgColor) Uint8() uint8 {
+	return uint8(c)
+}
+func (c FgColor) Int() int {
+	return int(c)
+}
+func (c BgColor) String() string {
+	return fmt.Sprintf("\x1b[%dm", c)
+}
+func (c BgColor) Uint8() uint8 {
+	return uint8(c)
+}
+func (c BgColor) Int() int {
+	return int(c)
+}
+
+func color256Fg(color uint8) string {
+	return fmt.Sprintf("\x1b[38;5;%dm", color)
+}
+func color256Bg(color uint8) string {
+	return fmt.Sprintf("\x1b[48;5;%dm", color)
+}
+func colorRgbFg(r, g, b uint8) string {
+	return fmt.Sprintf("\x1b[38;2;%d;%d;%dm", r, g, b)
+}
+func colorRgbBg(r, g, b uint8) string {
+	return fmt.Sprintf("\x1b[48;2;%d;%d;%dm", r, g, b)
+}

doc.go

@@ -0,0 +1,44 @@
+// Package sneklog provides a small structured logger that can write the same
+// record to text and JSON outputs.
+//
+// A Logger can fan out records to stdout, files, or any external io.Writer.
+// Text writers can include timestamps and a compact traceback frame. JSON
+// writers always emit a structured traceback slice.
+//
+// CreateLogger uses the following defaults:
+//   - prefix: "LOG"
+//   - level: FATAL, which enables info, warn, error, and fatal records
+//   - pretty JSON: disabled
+//   - text formatter: DefaultTextFormatter
+//   - JSON formatter: DefaultJsonFormatter
+//
+// Call Level(DEBUG) to enable all records, including debug messages.
+// AddReplacer can be used to mask or normalize message text before records are
+// passed to writers. Call SetFormatter on a writer to customize timestamps,
+// traceback fields, colors, and message layout.
+//
+// Basic usage:
+//
+//	logger := sneklog.CreateLogger().
+//		Prefix("API").
+//		Level(sneklog.DEBUG).
+//		AddReplacer("secret-token", "<redacted>")
+//
+//	text := logger.CreateTextStdoutWriter()
+//	jsonFile, err := logger.CreateJsonFileWriter("logs/app.json")
+//	if err != nil {
+//		panic(err)
+//	}
+//
+//	logger.AddWriters(text, jsonFile)
+//	logger.Infoln("service started", "secret-token")
+//
+//	if err := logger.Close(); err != nil {
+//		panic(err)
+//	}
+//
+// Writers created with CreateTextFileWriter or CreateJsonFileWriter are owned by
+// the logger and are closed by Logger.Close. Writers created from existing
+// io.Writer values through CreateTextWriter or CreateJsonWriter remain owned by
+// the caller and are not closed by the logger.
+package sneklog

examples/main.go

@@ -1,21 +1,80 @@
 package main
 
-import "git.nix13.pw/scuroneko/slog"
+import (
+	"bytes"
+	"fmt"
+
+	"git.scuroneko.dev/scuroneko/slog/v2"
+)
 
 func main() {
-	logger := slog.CreateLogger().JsonPretty(false)
+	logger := sneklog.CreateLogger().
-	defer logger.Close()
+		Prefix("EXAMPLE").
-	logger.AddWriter(logger.CreateTextStdoutWriter())
+		Level(sneklog.DEBUG).
-	f, err := logger.CreateJsonFileWriter("main.log")
+		JsonPretty(true).
+		AddReplacer("SOME_SECRET", "<Secret>")
+
+	sneklog.INFO.SetBgColor(sneklog.BgBlue).SetFgColor(sneklog.FgWhite)
+
+	textStdout := logger.CreateTextStdoutWriter()
+	jsonStdout := logger.CreateJsonStdoutWriter()
+
+	formatter := sneklog.NewFormatter().
+		SetFormat("[%t] [%L] [%N]: %m (%S)").
+		SetTimeStampFormat(sneklog.Kitchen).
+		SetTraceBackFormat("%s %f:%n %p")
+
+	jsonFormatter := sneklog.NewFormatter().
+		SetFormat("[%L] [%N] %m").
+		SetColorOutput(true).
+		SetTimeStampFormat(sneklog.Kitchen)
+
+	textStdout.SetFormatter(formatter)
+	jsonStdout.SetFormatter(jsonFormatter)
+
+	textFile, err := logger.CreateTextFileWriter("logs/text.log")
 	if err != nil {
+		logger.Close()
 		panic(err)
 	}
-	logger.AddWriter(f)
+
-	logger.Infoln("Test")
+	jsonFile, err := logger.CreateJsonFileWriter("logs/json.log")
-	logger.Warnln("Test")
+	if err != nil {
-	logger.Errorln("Test")
+		logger.Close()
-	logger.Debugln("Test") // No output
+		panic(err)
-	logger.Level(slog.DEBUG)
+	}
-	logger.Debugln("Test") // Now we have output
+
-	logger.Fatalln("Test") // Exit code 1
+	var externalBuffer bytes.Buffer
+	externalText := logger.CreateTextWriter(&externalBuffer)
+	externalJSON := logger.CreateJsonWriter(&externalBuffer)
+
+	logger.AddWriters(
+		textStdout,
+		jsonStdout,
+		textFile,
+		jsonFile,
+		externalText,
+		externalJSON,
+	)
+
+	logger.Infoln("service started")
+	logger.Warnln("cache miss")
+	logger.Errorln("request failed")
+	logger.Debugln("debug details")
+	logger.Infoln("sensitive info, SOME_SECRET")
+
+	if err := logger.Close(); err != nil {
+		panic(err)
+	}
+
+	s := sneklog.NewColorStringBuilder().
+		AddColorRgbBg(31, 41, 40).
+		AddColorRgbFg(220, 215, 186).
+		AddAttribute(sneklog.Italic).AddAttribute(sneklog.Bold).
+		AddText("Some Very very very cool stuff, themed in Kanagawa colors!").String()
+
+	println(s)
+
+	fmt.Println("external buffer contents:")
+	fmt.Println(externalBuffer.String())
 }

formatter.go

@@ -0,0 +1,166 @@
+package sneklog
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// Formatter
+// Format: %t - time, %N - name, %l - level, %L - level uppercase, %b - traceback, %B - full traceback, %m - message,
+// %M - method, %f - filename, %n - line number, %s - method signature, %p - full path
+// Example: "%t [%l] %N: %m (%f:%n %s)"
+//
+// TimeStampFormat: %Y - year, %m - month, %d - day, %H - hour, %M - minute, %S - second,
+// %z - timezone(i.e. 0300), %Z - timezone(i.e. 03:00)
+// Example: "%d.%m.%Y %H:%M:%S"
+//
+// TraceBackFormat: %M - method, %f - filename, %n - line number, %s - method signature, %p - full path
+type Formatter struct {
+	Format           string
+	MessageSeparator string
+
+	// JSONTraceBackPath
+	// If true, in traceback will be path to file, otherwise only filename.
+	JSONTraceBackPath  bool
+	TimeStampFormat    string
+	TraceBackFormat    string
+	TraceBackSeparator string
+
+	ColorOutput     bool
+	ColorOnlyStdout bool
+}
+
+var DefaultTextFormatter = &Formatter{
+	Format:             "%t %l %N: %m",
+	MessageSeparator:   " ",
+	TimeStampFormat:    RFC3339,
+	TraceBackFormat:    "%M (%f:%n %s)",
+	TraceBackSeparator: "->",
+	ColorOutput:        true,
+	ColorOnlyStdout:    true,
+}
+var DefaultJsonFormatter = &Formatter{
+	Format:           "%m",
+	MessageSeparator: " ",
+	TimeStampFormat:  RFC3339,
+	ColorOutput:      false,
+}
+
+func NewFormatter() *Formatter {
+	return &Formatter{
+		Format:             DefaultTextFormatter.Format,
+		MessageSeparator:   DefaultTextFormatter.MessageSeparator,
+		TimeStampFormat:    DefaultTextFormatter.TimeStampFormat,
+		TraceBackFormat:    DefaultTextFormatter.TraceBackFormat,
+		TraceBackSeparator: DefaultTextFormatter.TraceBackSeparator,
+		ColorOutput:        DefaultTextFormatter.ColorOutput,
+		ColorOnlyStdout:    DefaultTextFormatter.ColorOnlyStdout,
+	}
+}
+func (f *Formatter) SetFormat(format string) *Formatter {
+	f.Format = format
+	return f
+}
+func (f *Formatter) SetMessageSeparator(separator string) *Formatter {
+	f.MessageSeparator = separator
+	return f
+}
+func (f *Formatter) SetTimeStampFormat(format string) *Formatter {
+	f.TimeStampFormat = format
+	return f
+}
+func (f *Formatter) SetTraceBackFormat(format string) *Formatter {
+	f.TraceBackFormat = format
+	return f
+}
+func (f *Formatter) SetTraceBackSeparator(separator string) *Formatter {
+	f.TraceBackSeparator = separator
+	return f
+}
+func (f *Formatter) SetColorOutput(color bool) *Formatter {
+	f.ColorOutput = color
+	return f
+}
+func (f *Formatter) SetColorOnlyStdout(only bool) *Formatter {
+	f.ColorOnlyStdout = only
+	return f
+}
+
+func (f *Formatter) FormatMessage(level LogLevel, prefix string, tb []*MethodTraceback, messages ...any) string {
+	if f == nil {
+		return fmt.Sprint(messages...)
+	}
+	output := f.Format
+	output = strings.ReplaceAll(output, "%t", f.FormatTime(time.Now()))
+	output = strings.ReplaceAll(output, "%N", prefix)
+	output = strings.ReplaceAll(output, "%l", level.GetName())
+	output = strings.ReplaceAll(output, "%L", strings.ToUpper(level.GetName()))
+
+	if len(tb) > 0 {
+		formattedTraceback := f.FormatTraceback(tb[0])
+		output = strings.ReplaceAll(output, "%b", formattedTraceback)
+
+		formattedTraceback = f.FormatTracebacks(tb)
+		output = strings.ReplaceAll(output, "%B", formattedTraceback)
+	} else {
+		output = strings.ReplaceAll(output, "%b", "")
+		output = strings.ReplaceAll(output, "%B", "")
+	}
+
+	if len(tb) > 0 {
+		output = strings.ReplaceAll(output, "%M", tb[0].Method)
+		output = strings.ReplaceAll(output, "%f", tb[0].Filename)
+		output = strings.ReplaceAll(output, "%n", fmt.Sprintf("%d", tb[0].Line))
+		output = strings.ReplaceAll(output, "%s", tb[0].Signature)
+	} else {
+		output = strings.ReplaceAll(output, "%M", "")
+		output = strings.ReplaceAll(output, "%f", "")
+		output = strings.ReplaceAll(output, "%n", "")
+		output = strings.ReplaceAll(output, "%s", "")
+	}
+
+	if f.JSONTraceBackPath && len(tb) > 0 {
+		output = strings.ReplaceAll(output, "%p", tb[0].FullPath)
+	} else {
+		output = strings.ReplaceAll(output, "%p", "")
+	}
+
+	message := Map(messages, func(m any) string { return fmt.Sprint(m) })
+	output = strings.ReplaceAll(output, "%m", strings.Join(message, f.MessageSeparator))
+
+	return output
+}
+
+func (f *Formatter) ColorizeString(s string, level LogLevel) string {
+	return NewColorStringBuilder().
+		AddFgColor(level.fg).AddBgColor(level.bg).
+		AddText(s).AddReset().String()
+}
+
+func (f *Formatter) FormatTime(t time.Time) string {
+	if f.TimeStampFormat == "" {
+		return t.Format(time.RFC3339)
+	}
+	return t.Format(StrftimeToGo(f.TimeStampFormat))
+}
+func (f *Formatter) FormatTraceback(traceback *MethodTraceback) string {
+	formattedTraceback := f.TraceBackFormat
+	if f.JSONTraceBackPath {
+		formattedTraceback = strings.ReplaceAll(formattedTraceback, "%p", traceback.FullPath)
+	} else {
+		formattedTraceback = strings.ReplaceAll(formattedTraceback, "%p", "")
+	}
+	formattedTraceback = strings.ReplaceAll(formattedTraceback, "%M", traceback.Method)
+	formattedTraceback = strings.ReplaceAll(formattedTraceback, "%f", traceback.Filename)
+	formattedTraceback = strings.ReplaceAll(formattedTraceback, "%n", fmt.Sprintf("%d", traceback.Line))
+	formattedTraceback = strings.ReplaceAll(formattedTraceback, "%s", traceback.Signature)
+	return formattedTraceback
+}
+func (f *Formatter) FormatTracebacks(traceback []*MethodTraceback) string {
+	var formattedTraceback []string
+	for _, frame := range traceback {
+		formattedTraceback = append(formattedTraceback, f.FormatTraceback(frame))
+	}
+	return strings.Join(formattedTraceback, f.TraceBackSeparator)
+}

go.mod

@@ -1,11 +1,3 @@
-module git.nix13.pw/scuroneko/slog
+module git.scuroneko.dev/scuroneko/slog/v2
 
-go 1.25
+go 1.26
-
-require github.com/fatih/color v1.18.0
-
-require (
-	github.com/mattn/go-colorable v0.1.14 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	golang.org/x/sys v0.40.0 // indirect
-)

go.sum

@@ -1,9 +0,0 @@
-github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
-github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
-golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=

io.go

@@ -1,59 +1,84 @@
-package slog
+package sneklog
 
 import (
 	"fmt"
 	"os"
 )
 
+// Infof logs a formatted info message.
 func (l *Logger) Infof(format string, args ...any) {
 	l.print(INFO, fmt.Sprintf(format, args...))
 }
+
+// Info logs an info message.
 func (l *Logger) Info(m ...any) {
 	l.print(INFO, m...)
 }
+
+// Infoln logs an info message and appends a newline semantic for writers that need it.
 func (l *Logger) Infoln(m ...any) {
 	l.println(INFO, m...)
 }
 
+// Warnf logs a formatted warning message.
 func (l *Logger) Warnf(format string, args ...any) {
 	l.print(WARN, fmt.Sprintf(format, args...))
 }
+
+// Warn logs a warning message.
 func (l *Logger) Warn(m ...any) {
 	l.print(WARN, m...)
 }
+
+// Warnln logs a warning message with newline semantic.
 func (l *Logger) Warnln(m ...any) {
 	l.println(WARN, m...)
 }
 
+// Errorf logs a formatted error message.
 func (l *Logger) Errorf(format string, args ...any) {
 	l.print(ERROR, fmt.Sprintf(format, args...))
 }
+
+// Error logs an error message.
 func (l *Logger) Error(m ...any) {
 	l.print(ERROR, m...)
 }
+
+// Errorln logs an error message with newline semantic.
 func (l *Logger) Errorln(m ...any) {
 	l.println(ERROR, m...)
 }
 
+// Fatalf logs a formatted fatal message and exits the process with code 1.
 func (l *Logger) Fatalf(format string, args ...any) {
 	l.print(FATAL, fmt.Sprintf(format, args...))
 	os.Exit(1)
 }
+
+// Fatal logs a fatal message and exits the process with code 1.
 func (l *Logger) Fatal(m ...any) {
 	l.print(FATAL, m...)
 	os.Exit(1)
 }
+
+// Fatalln logs a fatal message with newline semantic and exits the process with code 1.
 func (l *Logger) Fatalln(m ...any) {
 	l.println(FATAL, m...)
 	os.Exit(1)
 }
 
+// Debugf logs a formatted debug message.
 func (l *Logger) Debugf(format string, args ...any) {
 	l.print(DEBUG, fmt.Sprintf(format, args...))
 }
+
+// Debug logs a debug message.
 func (l *Logger) Debug(m ...any) {
 	l.print(DEBUG, m...)
 }
+
+// Debugln logs a debug message with newline semantic.
 func (l *Logger) Debugln(m ...any) {
 	l.println(DEBUG, m...)
 }
@@ -73,7 +98,7 @@ func (l *Logger) print(level LogLevel, m ...any) {
 		if writer == nil {
 			continue
 		}
-		err := writer.Print(level, l.prefix, tb, m...)
+		err := writer.Print(level, l.prefix, tb, l.replaceAll(m...)...)
 		if err != nil {
 			l.reportWriterError(err)
 		}
@@ -96,7 +121,7 @@ func (l *Logger) println(level LogLevel, m ...any) {
 		if writer == nil {
 			continue
 		}
-		err := writer.Print(level, l.prefix, tb, messages...)
+		err := writer.Print(level, l.prefix, tb, l.replaceAll(messages...)...)
 		if err != nil {
 			l.reportWriterError(err)
 		}

logger.go

@@ -1,35 +1,53 @@
-package slog
+package sneklog
 
 import (
 	"errors"
 	"fmt"
 	"io"
 	"strings"
-	"time"
-
-	"github.com/fatih/color"
 )
 
+type replacer struct {
+	old string
+	new string
+}
+
+func (r replacer) replace(s string) string {
+	return strings.ReplaceAll(s, r.old, r.new)
+}
+
+// Logger routes log records to one or more configured writers.
 type Logger struct {
 	prefix    string
 	level     LogLevel
 	writers   []LoggerWriter
+	replacers []replacer
 
-	printTraceback bool
-	printTime      bool
 	jsonPretty bool
 }
 
+// LogLevel describes a logging severity.
 type LogLevel struct {
 	n  uint8
 	t  string
-	c color.Attribute
+	fg FgColor
+	bg BgColor
 }
 
-func (l *LogLevel) GetName() string {
+// GetName returns the lowercase textual representation of the level.
-	return l.t
+func (l *LogLevel) GetName() string     { return l.t }
+func (l *LogLevel) GetFgColor() FgColor { return l.fg }
+func (l *LogLevel) SetFgColor(color FgColor) *LogLevel {
+	l.fg = color
+	return l
+}
+func (l *LogLevel) GetBgColor() BgColor { return l.bg }
+func (l *LogLevel) SetBgColor(color BgColor) *LogLevel {
+	l.bg = color
+	return l
 }
 
+// MethodTraceback describes a single stack frame attached to a log entry.
 type MethodTraceback struct {
 	Method    string `json:"method"`
 	Filename  string `json:"filename"`
@@ -38,51 +56,68 @@ type MethodTraceback struct {
 	FullPath  string `json:"fullPath"`
 }
 
+// Predefined log levels.
 var (
-	INFO  = LogLevel{n: 0, t: "info", c: color.FgWhite}
+	INFO  = LogLevel{n: 0, t: "info", fg: FgWhite}
-	WARN  = LogLevel{n: 1, t: "warn", c: color.FgHiYellow}
+	WARN  = LogLevel{n: 1, t: "warn", fg: FgHiYellow}
-	ERROR = LogLevel{n: 2, t: "error", c: color.FgHiRed}
+	ERROR = LogLevel{n: 2, t: "error", fg: FgHiRed}
-	FATAL = LogLevel{n: 3, t: "fatal", c: color.FgRed}
+	FATAL = LogLevel{n: 3, t: "fatal", fg: FgRed}
-	DEBUG = LogLevel{n: 4, t: "debug", c: color.FgGreen}
+	DEBUG = LogLevel{n: 4, t: "debug", fg: FgGreen}
 )
 
+// CreateLogger creates a logger with default settings.
 func CreateLogger() *Logger {
 	return &Logger{
 		prefix: "LOG",
 		level:  FATAL,
-		printTraceback: false,
-		printTime:      true,
 	}
 }
 
+// Prefix sets the record prefix and returns the logger for chaining.
 func (l *Logger) Prefix(prefix string) *Logger {
 	l.prefix = prefix
 	return l
 }
+
+// Level sets the maximum enabled level and returns the logger for chaining.
 func (l *Logger) Level(level LogLevel) *Logger {
 	l.level = level
 	return l
 }
-func (l *Logger) PrintTraceback(b bool) *Logger {
+
-	l.printTraceback = b
+// JsonPretty enables indented JSON output for JSON writers.
-	return l
-}
-func (l *Logger) PrintTime(b bool) *Logger {
-	l.printTime = b
-	return l
-}
 func (l *Logger) JsonPretty(b bool) *Logger {
 	l.jsonPretty = b
 	return l
 }
+
+// AddWriters appends multiple writers to the logger.
 func (l *Logger) AddWriters(writers ...LoggerWriter) *Logger {
 	l.writers = append(l.writers, writers...)
 	return l
 }
+
+// AddWriter appends a single writer to the logger.
 func (l *Logger) AddWriter(writer LoggerWriter) *Logger {
 	l.writers = append(l.writers, writer)
 	return l
 }
+
+// AddReplacer appends a message replacer and returns the logger for chaining.
+//
+// Replacement rules are applied before records are passed to writers. Empty old
+// values are ignored because replacing an empty string would insert the
+// replacement between every UTF-8 sequence.
+func (l *Logger) AddReplacer(old, new string) *Logger {
+	if old == "" {
+		return l
+	}
+	r := replacer{old: old, new: new}
+	l.replacers = append(l.replacers, r)
+	return l
+}
+
+// Close closes all owned writers and returns a joined error, if any.
 func (l *Logger) Close() error {
 	var errs []error
 	for _, writer := range l.writers {
@@ -98,55 +133,51 @@ func (l *Logger) Close() error {
 	return errors.Join(errs...)
 }
 
+// CreateTextWriter wraps an external writer with the logger text settings.
 func (l *Logger) CreateTextWriter(w io.Writer) *LoggerTextWriter {
-	return CreateTextWriter(w, l.printTraceback, l.printTime)
+	return CreateTextWriter(w)
 }
+
+// CreateTextStdoutWriter creates a non-owning text writer for os.Stdout.
 func (l *Logger) CreateTextStdoutWriter() *LoggerTextWriter {
-	return CreateTextStdoutWriter(l.printTraceback, l.printTime)
+	return CreateTextStdoutWriter()
 }
+
+// CreateTextFileWriter creates an owning text writer for a file.
 func (l *Logger) CreateTextFileWriter(filename string) (*LoggerTextWriter, error) {
-	return CreateTextFileWriter(filename, l.printTraceback, l.printTime)
+	return CreateTextFileWriter(filename)
 }
+
+// CreateJsonWriter wraps an external writer with the logger JSON settings.
 func (l *Logger) CreateJsonWriter(w io.Writer) *LoggerJsonWriter {
 	return CreateJsonWriter(w, l.jsonPretty)
 }
+
+// CreateJsonStdoutWriter creates a non-owning JSON writer for os.Stdout.
 func (l *Logger) CreateJsonStdoutWriter() *LoggerJsonWriter {
 	return CreateJsonStdoutWriter(l.jsonPretty)
 }
+
+// CreateJsonFileWriter creates an owning JSON writer for a file.
 func (l *Logger) CreateJsonFileWriter(filename string) (*LoggerJsonWriter, error) {
 	return CreateJsonFileWriter(filename, l.jsonPretty)
 }
 
-func FormatTime(t time.Time) string {
+func (l *Logger) replace(s string) string {
-	return fmt.Sprintf("%02d.%02d.%02d %02d:%02d:%02d", t.Day(), t.Month(), t.Year(), t.Hour(), t.Minute(), t.Second())
+	out := s
+	for _, repl := range l.replacers {
+		out = repl.replace(out)
 	}
-func FormatTraceback(mt *MethodTraceback) string {
+	return out
-	return fmt.Sprintf("%s:%s:%d", mt.Filename, mt.Method, mt.Line)
-}
-func FormatFullTraceback(tracebacks []*MethodTraceback) string {
-	formatted := make([]string, 0)
-	for _, tb := range tracebacks {
-		formatted = append(formatted, FormatTraceback(tb))
-	}
-	return strings.Join(formatted, "->")
-}
-func BuildString(level LogLevel, prefix string, printTime, printTraceback bool, m ...any) string {
-	args := []string{
-		fmt.Sprintf("[%s]", prefix),
-		fmt.Sprintf("[%s]", strings.ToUpper(level.t)),
 }
 
-	if printTraceback {
+func (l *Logger) replaceAll(messages ...any) []any {
-		args = append(args, fmt.Sprintf("[%s]", FormatTraceback(getTraceback())))
+	if len(l.replacers) == 0 {
+		return messages
 	}
-
+	out := make([]any, len(messages))
-	if printTime {
+	for i, msg := range messages {
-		args = append(args, fmt.Sprintf("[%s]", FormatTime(time.Now())))
+		out[i] = l.replace(fmt.Sprint(msg))
 	}
-
+	return out
-	msg := Map(m, func(el any) string {
-		return fmt.Sprintf("%v", el)
-	})
-	s := fmt.Sprintf("%s %s", strings.Join(args, " "), strings.Join(msg, " "))
-	return s
 }

logger_test.go

@@ -1,9 +1,11 @@
-package slog
+package sneklog
 
 import (
 	"bytes"
+	"encoding/json"
 	"errors"
 	"os"
+	"strings"
 	"testing"
 )
 
@@ -12,8 +14,12 @@ type stubLoggerWriter struct {
 	closeErr   error
 	printCalls int
 	closeCalls int
+	messages   []any
 }
 
+func (w *stubLoggerWriter) Formatter() *Formatter {
+	return &Formatter{}
+}
 func (w *stubLoggerWriter) Close() error {
 	w.closeCalls++
 	return w.closeErr
@@ -23,8 +29,9 @@ func (w *stubLoggerWriter) Write(p []byte) (int, error) {
 	return len(p), nil
 }
 
-func (w *stubLoggerWriter) Print(_ LogLevel, _ string, _ []*MethodTraceback, _ ...any) error {
+func (w *stubLoggerWriter) Print(_ LogLevel, _ string, _ []*MethodTraceback, messages ...any) error {
 	w.printCalls++
+	w.messages = append([]any(nil), messages...)
 	return w.printErr
 }
 
@@ -79,8 +86,22 @@ func TestLoggerPrintDoesNotRecurseOnWriterError(t *testing.T) {
 	}
 }
 
+func TestLoggerPreservesMessageTypesWithoutReplacers(t *testing.T) {
+	writer := &stubLoggerWriter{}
+	logger := CreateLogger().AddWriter(writer)
+
+	logger.Error("status", 500)
+
+	if len(writer.messages) != 2 {
+		t.Fatalf("writer should receive two messages, got %d", len(writer.messages))
+	}
+	if _, ok := writer.messages[1].(int); !ok {
+		t.Fatalf("writer should receive original int message type, got %T", writer.messages[1])
+	}
+}
+
 func TestCreateTextWriterCloseOnNonCloserIsNoOp(t *testing.T) {
-	writer := CreateTextWriter(&bytes.Buffer{}, false, false)
+	writer := CreateTextWriter(&bytes.Buffer{})
 	if err := writer.Close(); err != nil {
 		t.Fatalf("Close() error = %v", err)
 	}
@@ -95,7 +116,7 @@ func TestCreateTextWriterDoesNotCloseExternalCloser(t *testing.T) {
 		_ = file.Close()
 	})
 
-	writer := CreateTextWriter(file, false, false)
+	writer := CreateTextWriter(file)
 	if err := writer.Close(); err != nil {
 		t.Fatalf("Close() error = %v", err)
 	}
@@ -129,10 +150,111 @@ func TestCreateJsonWriterDoesNotCloseExternalCloser(t *testing.T) {
 	}
 }
 
+func TestJsonWriterPrintAllowsEmptyMessages(t *testing.T) {
+	var buf bytes.Buffer
+	writer := CreateJsonWriter(&buf, false)
+
+	if err := writer.Print(INFO, "TEST", nil); err != nil {
+		t.Fatalf("Print() error = %v", err)
+	}
+
+	var message LoggerJsonMessage
+	if err := json.Unmarshal(buf.Bytes(), &message); err != nil {
+		t.Fatalf("json.Unmarshal() error = %v", err)
+	}
+	if message.Message != "" {
+		t.Fatalf("message should be empty, got %q", message.Message)
+	}
+}
+
+func TestJsonWriterPrintPreservesTrailingNewlineSemantic(t *testing.T) {
+	var buf bytes.Buffer
+	writer := CreateJsonWriter(&buf, false)
+
+	if err := writer.Print(INFO, "TEST", nil, "hello\n"); err != nil {
+		t.Fatalf("Print() error = %v", err)
+	}
+
+	data := buf.Bytes()
+	if !bytes.HasSuffix(data, []byte("\n")) {
+		t.Fatalf("JSON output should end with newline, got %q", data)
+	}
+
+	var message LoggerJsonMessage
+	if err := json.Unmarshal(bytes.TrimSuffix(data, []byte("\n")), &message); err != nil {
+		t.Fatalf("json.Unmarshal() error = %v", err)
+	}
+	if message.Message != "hello" {
+		t.Fatalf("message should not include trailing newline, got %q", message.Message)
+	}
+}
+
+func TestFormatterHandlesEmptyTracebackPlaceholders(t *testing.T) {
+	formatter := NewFormatter().
+		SetFormat("%m|%b|%B|%M|%f|%n|%s|%p")
+
+	got := formatter.FormatMessage(INFO, "TEST", nil, "hello")
+	if got != "hello|||||||" {
+		t.Fatalf("empty traceback placeholders should be empty, got %q", got)
+	}
+}
+
+func TestFormatterDoesNotInterpretPlaceholdersInsideMessages(t *testing.T) {
+	formatter := NewFormatter().
+		SetFormat("%L:%m")
+
+	message := "literal %L %s %p"
+	got := formatter.FormatMessage(INFO, "TEST", nil, message)
+	if got != "INFO:literal %L %s %p" {
+		t.Fatalf("message placeholder-looking text should stay literal, got %q", got)
+	}
+}
+
+func TestNewFormatterDoesNotMutateDefaultFormatter(t *testing.T) {
+	formatter := NewFormatter()
+	formatter.SetFormat("custom")
+
+	if DefaultTextFormatter.Format == "custom" {
+		t.Fatal("NewFormatter() should return a copy, not mutate DefaultTextFormatter")
+	}
+}
+
+func TestTextWriterColorOutputHonorsColorOnlyStdoutFalse(t *testing.T) {
+	var buf bytes.Buffer
+	formatter := NewFormatter().
+		SetFormat("%m").
+		SetColorOutput(true).
+		SetColorOnlyStdout(false)
+	writer := CreateTextWriter(&buf).SetFormatter(formatter)
+
+	if err := writer.Print(INFO, "TEST", nil, "hello"); err != nil {
+		t.Fatalf("Print() error = %v", err)
+	}
+	if !strings.Contains(buf.String(), "\x1b[") {
+		t.Fatalf("ColorOnlyStdout(false) should allow color for external writers, got %q", buf.String())
+	}
+}
+
+func TestTextWriterColorOutputCanBeDisabled(t *testing.T) {
+	var buf bytes.Buffer
+	formatter := NewFormatter().
+		SetFormat("%m").
+		SetColorOutput(false).
+		SetColorOnlyStdout(false)
+	writer := CreateTextWriter(&buf).SetFormatter(formatter)
+
+	if err := writer.Print(INFO, "TEST", nil, "hello"); err != nil {
+		t.Fatalf("Print() error = %v", err)
+	}
+	if strings.Contains(buf.String(), "\x1b[") {
+		t.Fatalf("SetColorOutput(false) should disable color output, got %q", buf.String())
+	}
+}
+
 func TestCreateTextStdoutWriterDoesNotCloseStdout(t *testing.T) {
 	stdoutFile := swapStdout(t)
 
-	writer := CreateTextStdoutWriter(false, false)
+	writer := CreateTextStdoutWriter()
 	if err := writer.Close(); err != nil {
 		t.Fatalf("Close() error = %v", err)
 	}
@@ -153,6 +275,42 @@ func TestCreateJsonStdoutWriterDoesNotCloseStdout(t *testing.T) {
 	}
 }
 
+func TestGetFullTracebackSkipsRuntimeAndSlogFrames(t *testing.T) {
+	tracebacks := captureTracebackForTest()
+	if len(tracebacks) == 0 {
+		t.Fatal("expected at least one traceback frame")
+	}
+
+	first := tracebacks[0]
+	if first.Method != "captureTracebackForTest" {
+		t.Fatalf("first frame should be the nearest user frame, got %s", first.Method)
+	}
+	for _, tb := range tracebacks {
+		if strings.HasPrefix(tb.Signature, "runtime.") {
+			t.Fatalf("runtime frame should be filtered out, got %s", tb.Signature)
+		}
+		if _, ok := internalTracebackMethods[tb.Method]; ok {
+			t.Fatalf("internal slog frame should be filtered out, got %s", tb.Signature)
+		}
+	}
+}
+
+func TestGetTracebackReturnsNearestUserFrame(t *testing.T) {
+	tb := captureSingleTracebackForTest()
+	if tb == nil {
+		t.Fatal("expected traceback frame")
+	}
+	if tb.Method != "captureSingleTracebackForTest" {
+		t.Fatalf("expected nearest user frame, got %s", tb.Method)
+	}
+	if strings.HasPrefix(tb.Signature, "runtime.") {
+		t.Fatalf("runtime frame should be filtered out, got %s", tb.Signature)
+	}
+	if _, ok := internalTracebackMethods[tb.Method]; ok {
+		t.Fatalf("internal slog frame should be filtered out, got %s", tb.Signature)
+	}
+}
+
 func swapStdout(t *testing.T) *os.File {
 	t.Helper()
 
@@ -168,3 +326,11 @@ func swapStdout(t *testing.T) *os.File {
 	})
 	return stdoutFile
 }
+
+func captureTracebackForTest() []*MethodTraceback {
+	return getFullTraceback(0)
+}
+
+func captureSingleTracebackForTest() *MethodTraceback {
+	return getTraceback()
+}

time_format.go

@@ -0,0 +1,161 @@
+package sneklog
+
+import "strings"
+
+const (
+	Layout   = "%m/%d %I:%M:%S%p '%y %z"
+	ANSIC    = "%a %b %e %H:%M:%S %Y"
+	UnixDate = "%a %b %e %H:%M:%S %Z %Y"
+	RubyDate = "%a %b %d %H:%M:%S %z %Y"
+
+	RFC822      = "%d %b %y %H:%M %Z"
+	RFC822Z     = "%d %b %y %H:%M %z"
+	RFC850      = "%A, %d-%b-%y %H:%M:%S %Z"
+	RFC1123     = "%a, %d %b %Y %H:%M:%S %Z"
+	RFC1123Z    = "%a, %d %b %Y %H:%M:%S %z"
+	RFC3339     = "%Y-%m-%dT%H:%M:%S%:z"
+	RFC3339Nano = "%Y-%m-%dT%H:%M:%S%#N%:z"
+	Kitchen     = "%-I:%M%p"
+
+	Stamp      = "%b %e %H:%M:%S"
+	StampMilli = "%b %e %H:%M:%S.%L"
+	StampMicro = "%b %e %H:%M:%S.%f"
+	StampNano  = "%b %e %H:%M:%S.%N"
+	DateTime   = "%Y-%m-%d %H:%M:%S"
+	DateOnly   = "%Y-%m-%d"
+	TimeOnly   = "%H:%M:%S"
+)
+
+type rule struct {
+	strf     string
+	goLayout string
+}
+
+var strftimeToGoRules = []rule{
+	// Long/special tokens first.
+	{"%::z", "Z07:00:00"},
+	{"%:::z", "Z07"},
+	{"%:z", "Z07:00"},
+
+	{"%#N", ".999999999"},
+	{"%#f", ".999999"},
+	{"%#L", ".999"},
+
+	{"%-m", "1"},
+	{"%#m", "1"},
+	{"%-d", "2"},
+	{"%#d", "2"},
+	{"%-H", "15"},
+	{"%#H", "15"},
+	{"%-I", "3"},
+	{"%#I", "3"},
+	{"%-M", "4"},
+	{"%#M", "4"},
+	{"%-S", "5"},
+	{"%#S", "5"},
+
+	{"%%", "%"},
+
+	{"%Y", "2006"},
+	{"%y", "06"},
+
+	{"%B", "January"},
+	{"%b", "Jan"},
+	{"%h", "Jan"},
+	{"%m", "01"},
+
+	{"%d", "02"},
+	{"%e", "_2"},
+
+	{"%A", "Monday"},
+	{"%a", "Mon"},
+
+	{"%H", "15"},
+	{"%I", "03"},
+	{"%M", "04"},
+	{"%S", "05"},
+
+	{"%p", "PM"},
+
+	{"%z", "-0700"},
+	{"%Z", "MST"},
+
+	{"%N", "000000000"},
+	{"%f", "000000"},
+	{"%L", "000"},
+
+	{"%F", "2006-01-02"},
+	{"%T", "15:04:05"},
+	{"%R", "15:04"},
+	{"%D", "01/02/06"},
+	{"%r", "03:04:05 PM"},
+}
+
+func StrftimeToGo(format string) string {
+	var out strings.Builder
+
+	for i := 0; i < len(format); {
+		if format[i] != '%' {
+			out.WriteByte(format[i])
+			i++
+			continue
+		}
+
+		matched := false
+		for _, r := range strftimeToGoRules {
+			if strings.HasPrefix(format[i:], r.strf) {
+				out.WriteString(r.goLayout)
+				i += len(r.strf)
+				matched = true
+				break
+			}
+		}
+
+		if !matched {
+			// Можно заменить на ошибку, если хочешь strict mode.
+			out.WriteByte(format[i])
+			i++
+		}
+	}
+
+	return out.String()
+}
+
+func GoToStrftime(format string) string {
+	format = strings.ReplaceAll(format, "2006", "%Y")
+	format = strings.ReplaceAll(format, "06", "%y")
+
+	format = strings.ReplaceAll(format, "15", "%H")
+	format = strings.ReplaceAll(format, "03", "%I")
+	format = strings.ReplaceAll(format, "3", "%-I")
+	format = strings.ReplaceAll(format, "3", "%#I")
+
+	format = strings.ReplaceAll(format, "January", "%B")
+	format = strings.ReplaceAll(format, "Jan", "%b")
+	format = strings.ReplaceAll(format, "01", "%m")
+	format = strings.ReplaceAll(format, "1", "%-m")
+
+	format = strings.ReplaceAll(format, "02", "%d")
+	format = strings.ReplaceAll(format, "_2", "%e")
+	format = strings.ReplaceAll(format, "2", "%-d")
+
+	format = strings.ReplaceAll(format, "Monday", "%A")
+	format = strings.ReplaceAll(format, "Mon", "%a")
+
+	format = strings.ReplaceAll(format, "04", "%M")
+	format = strings.ReplaceAll(format, "05", "%S")
+	format = strings.ReplaceAll(format, ".999999999", "%#N")
+	format = strings.ReplaceAll(format, "000000000", "%N")
+	format = strings.ReplaceAll(format, ".999999", "%#f")
+	format = strings.ReplaceAll(format, "000000", "%f")
+	format = strings.ReplaceAll(format, ".999", "%#L")
+	format = strings.ReplaceAll(format, "000", "%L")
+	format = strings.ReplaceAll(format, "PM", "%p")
+
+	format = strings.ReplaceAll(format, "-0700", "%z")
+	format = strings.ReplaceAll(format, "MST", "%Z")
+	format = strings.ReplaceAll(format, "Z07:00", "%:z")
+	format = strings.ReplaceAll(format, "Z07:00:00", "%::z")
+	format = strings.ReplaceAll(format, "Z07", "%:::z")
+	return format
+}

traceback.go

@@ -1,60 +1,84 @@
-package slog
+package sneklog
 
 import (
 	"runtime"
-	"sort"
 	"strings"
 )
 
+var internalTracebackMethods = map[string]struct{}{
+	"Infof":             {},
+	"Info":              {},
+	"Infoln":            {},
+	"Warnf":             {},
+	"Warn":              {},
+	"Warnln":            {},
+	"Errorf":            {},
+	"Error":             {},
+	"Errorln":           {},
+	"Fatalf":            {},
+	"Fatal":             {},
+	"Fatalln":           {},
+	"Debugf":            {},
+	"Debug":             {},
+	"Debugln":           {},
+	"print":             {},
+	"println":           {},
+	"reportWriterError": {},
+	"getTraceback":      {},
+	"getFullTraceback":  {},
+}
+
 func getTraceback() *MethodTraceback {
-	caller, _, _, _ := runtime.Caller(5)
+	tracebacks := getFullTraceback(0)
-	details := runtime.FuncForPC(caller)
+	if len(tracebacks) == 0 {
-	signature := details.Name()
+		return nil
-	path, line := details.FileLine(caller)
+	}
-	splitPath := strings.Split(path, "/")
+	return tracebacks[0]
-
-	splitSignature := strings.Split(signature, ".")
-	method := splitSignature[len(splitSignature)-1]
-
-	tb := &MethodTraceback{
-		Filename:  splitPath[len(splitPath)-1],
-		FullPath:  path,
-		Line:      line,
-		Signature: signature,
-		Method:    method,
 }
 
-	return tb
-}
 func getFullTraceback(skip int) []*MethodTraceback {
 	pc := make([]uintptr, 15)
-	runtime.Callers(skip, pc)
+	n := runtime.Callers(skip+2, pc)
 	list := make([]*MethodTraceback, 0)
-	frames := runtime.CallersFrames(pc)
+	frames := runtime.CallersFrames(pc[:n])
 	for {
 		frame, more := frames.Next()
+		tb := buildMethodTraceback(frame.PC)
+		if tb != nil && !isInternalTraceback(tb) {
+			list = append(list, tb)
+		}
 		if !more {
 			break
 		}
-		details := runtime.FuncForPC(frame.PC)
+	}
-		signature := details.Name()
+	return list
-		path, line := details.FileLine(frame.PC)
+}
-		splitPath := strings.Split(path, "/")
 
+func buildMethodTraceback(pc uintptr) *MethodTraceback {
+	details := runtime.FuncForPC(pc)
+	if details == nil {
+		return nil
+	}
+
+	signature := details.Name()
+	path, line := details.FileLine(pc)
+	splitPath := strings.Split(path, "/")
 	splitSignature := strings.Split(signature, ".")
 	method := splitSignature[len(splitSignature)-1]
 
-		tb := &MethodTraceback{
+	return &MethodTraceback{
 		Filename:  splitPath[len(splitPath)-1],
 		FullPath:  path,
 		Line:      line,
 		Signature: signature,
 		Method:    method,
 	}
-		list = append(list, tb)
 }
-	sort.Slice(list, func(i, j int) bool {
+
-		return j < i
+func isInternalTraceback(tb *MethodTraceback) bool {
-	})
+	if strings.HasPrefix(tb.Signature, "runtime.") {
-	return list
+		return true
+	}
+	_, ok := internalTracebackMethods[tb.Method]
+	return ok
 }

utils.go

@@ -1,5 +1,6 @@
-package slog
+package sneklog
 
+// Map applies f to each element of s and returns the resulting slice.
 func Map[T, R any](s []T, f func(T) R) []R {
 	out := make([]R, len(s))
 	for i, el := range s {

writers.go

@@ -1,4 +1,4 @@
-package slog
+package sneklog
 
 import (
 	"encoding/json"
@@ -10,28 +10,67 @@ import (
 	"time"
 )
 
+// LoggerWriter is the common sink interface used by Logger.
 type LoggerWriter interface {
 	Close() error
 	Write(p []byte) (n int, err error)
 	Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error
 }
 
+// LoggerTextWriter writes human-readable log records to an io.Writer.
 type LoggerTextWriter struct {
 	LoggerWriter
 	writer    io.Writer
 	closer    io.Closer
-	printTraceback bool
+	formatter *Formatter
-	printTime      bool
 }
 
+func (w *LoggerTextWriter) SetFormatter(formatter *Formatter) *LoggerTextWriter {
+	w.formatter = formatter
+	return w
+}
+func (w *LoggerTextWriter) Formatter() *Formatter {
+	if w.formatter == nil {
+		return DefaultTextFormatter
+	}
+	return w.formatter
+}
+
+// Write forwards raw bytes to the underlying writer.
 func (w *LoggerTextWriter) Write(p []byte) (n int, err error) {
 	return w.writer.Write(p)
 }
-func (w *LoggerTextWriter) Print(level LogLevel, prefix string, _ []*MethodTraceback, messages ...any) error {
+
-	s := BuildString(level, prefix, w.printTime, w.printTraceback, messages...)
+// Print formats the provided record as text and writes it to the underlying writer.
+func (w *LoggerTextWriter) Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error {
+	msg := Map(messages, func(el any) string { return fmt.Sprint(el) })
+	newline := false
+	if len(msg) > 0 && strings.HasSuffix(msg[len(msg)-1], "\n") {
+		newline = true
+		msg[len(msg)-1] = strings.TrimSuffix(msg[len(msg)-1], "\n")
+	}
+	messages = Map(msg, func(el string) any { return any(el) })
+
+	f := w.Formatter()
+	s := f.FormatMessage(level, prefix, traceback, messages...)
+	if f.ColorOutput && (!f.ColorOnlyStdout || w.writer == os.Stdout || w.writer == os.Stderr) {
+		s = f.ColorizeString(s, level)
+	}
+
 	_, err := w.Write([]byte(s))
+	if err != nil {
 		return err
 	}
+	if newline {
+		_, err = w.Write([]byte("\n"))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Close closes the owned writer, if any.
 func (w *LoggerTextWriter) Close() error {
 	if w.closer == nil {
 		return nil
@@ -39,40 +78,63 @@ func (w *LoggerTextWriter) Close() error {
 	return w.closer.Close()
 }
 
-// LoggerJsonWriter write into writer JSON
+// LoggerJsonWriter writes structured log records as JSON.
 type LoggerJsonWriter struct {
 	LoggerWriter
 	writer io.Writer
 	closer io.Closer
 	pretty bool
+
+	formatter *Formatter
 }
+
+func (w *LoggerJsonWriter) Formatter() *Formatter {
+	if w.formatter == nil {
+		return DefaultJsonFormatter
+	}
+	return w.formatter
+}
+func (w *LoggerJsonWriter) SetFormatter(f *Formatter) *LoggerJsonWriter {
+	w.formatter = f
+	return w
+}
+
+// LoggerJsonMessage is the JSON payload emitted by LoggerJsonWriter.
 type LoggerJsonMessage struct {
-	Time      time.Time          `json:"time"`
+	Time    string `json:"time"`
 	Level   string `json:"level"`
 	Prefix  string `json:"prefix"`
 	Message string `json:"message"`
+
 	Traceback []*MethodTraceback `json:"traceback"`
 }
 
+// Write forwards raw bytes to the underlying writer.
 func (w *LoggerJsonWriter) Write(data []byte) (int, error) {
 	return w.writer.Write(data)
 }
-func (w *LoggerJsonWriter) Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error {
-	msg := Map(messages, func(el any) string {
-		return fmt.Sprintf("%v", el)
-	})
 
+// Print encodes the provided record as JSON and writes it to the underlying writer.
+func (w *LoggerJsonWriter) Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error {
+	msg := Map(messages, func(el any) string { return fmt.Sprint(el) })
 	newline := false
-	if msg[len(msg)-1] == "\n" {
+	if len(msg) > 0 && strings.HasSuffix(msg[len(msg)-1], "\n") {
 		newline = true
-		msg = msg[:len(msg)-1]
+		msg[len(msg)-1] = strings.TrimSuffix(msg[len(msg)-1], "\n")
+	}
+	messages = Map(msg, func(el string) any { return any(el) })
+
+	f := w.Formatter()
+	s := f.FormatMessage(level, prefix, traceback, messages...)
+	if f.ColorOutput && (!f.ColorOnlyStdout || w.writer == os.Stdout || w.writer == os.Stderr) {
+		s = f.ColorizeString(s, level)
 	}
 
 	m := LoggerJsonMessage{
-		Time:      time.Now(),
+		Time:      f.FormatTime(time.Now()),
 		Level:     level.GetName(),
 		Prefix:    prefix,
-		Message:   strings.TrimSpace(strings.Join(msg, " ")),
+		Message:   s,
 		Traceback: traceback,
 	}
 	var data []byte
@@ -91,6 +153,8 @@ func (w *LoggerJsonWriter) Print(level LogLevel, prefix string, traceback []*Met
 	_, err = w.Write(data)
 	return err
 }
+
+// Close closes the owned writer, if any.
 func (w *LoggerJsonWriter) Close() error {
 	if w.closer == nil {
 		return nil
@@ -98,13 +162,18 @@ func (w *LoggerJsonWriter) Close() error {
 	return w.closer.Close()
 }
 
-func CreateTextWriter(w io.Writer, printTraceback, printTime bool) *LoggerTextWriter {
+// CreateTextWriter wraps an external writer for text output without taking
+// ownership of it.
+func CreateTextWriter(w io.Writer) *LoggerTextWriter {
 	writer := &LoggerTextWriter{
-		writer: w, printTraceback: printTraceback, printTime: printTime,
+		writer: w,
 	}
 	return writer
 }
-func CreateTextFileWriter(path string, printTraceback, printTime bool) (*LoggerTextWriter, error) {
+
+// CreateTextFileWriter creates a text writer for path, creating parent
+// directories as needed. The returned writer owns the opened file.
+func CreateTextFileWriter(path string) (*LoggerTextWriter, error) {
 	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
 	if err != nil {
 		return nil, err
@@ -113,27 +182,38 @@ func CreateTextFileWriter(path string, printTraceback, printTime bool) (*LoggerT
 	if err != nil {
 		return nil, err
 	}
-	writer := CreateTextWriter(file, printTraceback, printTime)
+	writer := CreateTextWriter(file)
 	writer.closer = file
 	return writer, nil
 }
-func CreateTextStdoutWriter(printTraceback, printTime bool) *LoggerTextWriter {
+
-	writer := CreateTextWriter(os.Stdout, printTraceback, printTime)
+// CreateTextStdoutWriter creates a text writer for os.Stdout without taking
+// ownership of stdout.
+func CreateTextStdoutWriter() *LoggerTextWriter {
+	writer := CreateTextWriter(os.Stdout)
 	writer.closer = nil
 	return writer
 }
 
+// CreateJsonWriter wraps an external writer for JSON output without taking
+// ownership of it.
 func CreateJsonWriter(w io.Writer, pretty bool) *LoggerJsonWriter {
 	writer := &LoggerJsonWriter{
 		writer: w, pretty: pretty,
 	}
 	return writer
 }
+
+// CreateJsonStdoutWriter creates a JSON writer for os.Stdout without taking
+// ownership of stdout.
 func CreateJsonStdoutWriter(pretty bool) *LoggerJsonWriter {
 	writer := CreateJsonWriter(os.Stdout, pretty)
 	writer.closer = nil
 	return writer
 }
+
+// CreateJsonFileWriter creates a JSON writer for path, creating parent
+// directories as needed. The returned writer owns the opened file.
 func CreateJsonFileWriter(path string, pretty bool) (*LoggerJsonWriter, error) {
 	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
 	if err != nil {