package main

import "github.com/semihalev/zlog/v2"

func main() {
    // Simple key-value pairs
    zlog.Info("Application starting")
    zlog.Info("User logged in", "username", "john", "user_id", 12345)
    zlog.Error("Connection failed", "host", "localhost", "port", 5432)
    
    // Configure global logger
    zlog.SetLevel(zlog.LevelWarn)  // Only Warn, Error, Fatal will be logged
    
    // Or use typed fields for better performance (0 allocations)
    zlog.Error("Database error",
        zlog.String("host", "localhost"),
        zlog.Int("port", 5432),
        zlog.String("error", "connection refused"))
}

package main

import "github.com/semihalev/zlog/v2"

func main() {
    // Create logger instance with beautiful terminal output
    logger := zlog.New()
    logger.SetWriter(zlog.StdoutTerminal())
    
    // Basic logging
    logger.Debug("Application starting...")
    logger.Info("Server initialized successfully")
    logger.Warn("Configuration not found, using defaults")
    logger.Error("Failed to connect to database")
    logger.Fatal("Critical error, shutting down") // Exits with code 1
}

// Create structured logger with zero allocations
logger := zlog.NewStructured()
logger.SetWriter(zlog.StdoutTerminal())

// Log with typed fields - 0 allocations thanks to buffer pool!
logger.Info("User logged in",
    zlog.String("username", "john_doe"),
    zlog.Int("user_id", 12345),
    zlog.Bool("admin", true),
    zlog.Float64("session_time", 30.5))

logger.Error("Request failed",
    zlog.String("method", "POST"),
    zlog.String("path", "/api/users"),
    zlog.Int("status", 500),
    zlog.Uint64("duration_ns", 1234567))

// For maximum performance with zero allocations
logger := zlog.NewUltimateLogger()
logger.SetWriter(zlog.StdoutWriter())

// 21.88 ns/op with true zero allocations
logger.Info("Ultra-fast logging")
logger.Debug("This is incredibly fast")

// Can handle 45.7 million logs/second!

tw := zlog.NewTerminalWriter(os.Stdout).(*zlog.TerminalWriter)
tw.SetColorEnabled(false)
logger.SetWriter(tw)

logger.SetWriter(zlog.StdoutWriter()) // No colors, just plain text

// Create memory-mapped file writer for zero-syscall logging
mmap, err := zlog.NewMMapWriter("/var/log/app.log", 100*1024*1024) // 100MB
if err != nil {
    panic(err)
}
defer mmap.Close()

logger := zlog.New()
logger.SetWriter(mmap)

// Any io.Writer works - files, network connections, buffers, etc.
file, _ := os.Create("app.log")
logger := zlog.New()
logger.SetWriter(file)

// Or use multiple writers with io.MultiWriter
multi := io.MultiWriter(os.Stdout, file)
logger.SetWriter(multi)

// Custom implementation
type CustomWriter struct{}

func (w CustomWriter) Write(p []byte) (int, error) {
    // Your custom logic here
    return len(p), nil
}

logger.SetWriter(CustomWriter{})

logger := zlog.New()

// Set minimum log level
logger.SetLevel(zlog.LevelWarn) // Only Warn, Error, Fatal will be logged

// Check current level
if logger.GetLevel() <= zlog.LevelDebug {
    // Expensive debug operation
}

logger.Info("event",
    zlog.String("name", "John"),
    zlog.Int("age", 30),
    zlog.Int64("id", 123456789),
    zlog.Uint("count", 42),
    zlog.Uint64("total", 9999999),
    zlog.Float32("score", 98.5),
    zlog.Float64("precision", 3.14159265359),
    zlog.Bool("active", true),
    zlog.Bytes("data", []byte{0x01, 0x02, 0x03}))

// Create the fastest possible logger for request logging
logger := zlog.NewUltimateLogger()

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    
    // Your handler logic here
    
    // Log with 21.88 ns overhead
    logger.Info(fmt.Sprintf("%s %s %d %dns", 
        r.Method, r.URL.Path, 200, time.Since(start).Nanoseconds()))
})

// Structured logger for production with terminal output
logger := zlog.NewStructured()
logger.SetWriter(zlog.StdoutTerminal())

// Log with rich context
logger.Info("service started",
    zlog.String("version", "1.0.0"),
    zlog.String("env", "production"),
    zlog.Int("pid", os.Getpid()),
    zlog.String("node", hostname))

// Log errors with context
logger.Error("database query failed",
    zlog.String("query", query),
    zlog.String("error", err.Error()),
    zlog.Float64("duration_ms", duration.Seconds()*1000))