logger

package module
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 28, 2025 License: MIT Imports: 9 Imported by: 0

README

Logger - Sistema de Logging Unificado para Go

Um pacote de logging estruturado e flexível para Go que utiliza o padrão Adapter para permitir integração com diferentes bibliotecas de logging, com suporte completo a observabilidade e conformidade LGPD.

Características

  • Interface fluente com method chaining para construção de logs
  • Logging estruturado com campos tipados
  • Padrão Adapter para integração com diferentes bibliotecas de logging
  • Níveis de log padrão (DEBUG, INFO, WARN, ERROR, FATAL)
  • Propagação de contexto para rastreamento de requisições
  • Campos pré-definidos por instância do logger
  • Otimização de performance com verificação de nível habilitado
  • Observabilidade integrada com Datadog e ELK Stack
  • Middlewares HTTP para Gin, Fiber e Chi
  • Integração com PostgreSQL via PGX
  • Sanitização LGPD automática de dados sensíveis
  • Correlation IDs automáticos para rastreamento
  • Distributed tracing com Datadog
  • Métricas automáticas e dashboards
  • Adapter Zerolog incluído para uso imediato

Instalação

go get github.com/victorximenis/logger

Uso Básico

1. Inicialização Rápida com Perfis
package main

import (
    "context"
    "github.com/victorximenis/logger"
)

func main() {
    // Inicialização para produção (Datadog + ELK habilitados)
    err := logger.InitWithProfile("production", "my-service")
    if err != nil {
        panic(err)
    }

    ctx := context.Background()
    
    // Usar o logger global
    logger.Info(ctx).
        Str("user_id", "123").
        Int("attempt", 1).
        Msg("User login successful")
}
2. Configuração Manual com Observabilidade
package main

import (
    "context"
    "github.com/victorximenis/logger"
)

func main() {
    // Configuração personalizada
    config := logger.NewConfig()
    config.ServiceName = "auth-service"
    config.Environment = "production"
    config.LogLevel = core.INFO
    
    // Habilitar observabilidade
    config.Observability.Enabled = true
    config.Observability.EnableDatadog = true
    config.Observability.EnableELK = true
    config.Observability.EnableCorrelationID = true
    
    err := logger.Init(config)
    if err != nil {
        panic(err)
    }
    
    ctx := context.Background()
    logger.Info(ctx).Msg("Service started")
}
3. Usando Middlewares HTTP
Gin
package main

import (
    "github.com/gin-gonic/gin"
    "github.com/victorximenis/logger"
    "github.com/victorximenis/logger/middlewares"
)

func main() {
    logger.InitWithProfile("production", "api-service")
    
    r := gin.New()
    
    // Adicionar middleware de logging
    r.Use(middlewares.GinLogger())
    
    r.GET("/users/:id", func(c *gin.Context) {
        // O contexto já contém correlation_id, request_id, etc.
        logger.Info(c.Request.Context()).
            Str("user_id", c.Param("id")).
            Msg("User requested")
        
        c.JSON(200, gin.H{"status": "ok"})
    })
    
    r.Run(":8080")
}
Fiber
package main

import (
    "github.com/gofiber/fiber/v2"
    "github.com/victorximenis/logger"
    "github.com/victorximenis/logger/middlewares"
)

func main() {
    logger.InitWithProfile("production", "api-service")
    
    app := fiber.New()
    
    // Adicionar middleware de logging
    app.Use(middlewares.FiberLogger())
    
    app.Get("/users/:id", func(c *fiber.Ctx) error {
        // O contexto já contém correlation_id, request_id, etc.
        logger.Info(c.Context()).
            Str("user_id", c.Params("id")).
            Msg("User requested")
        
        return c.JSON(fiber.Map{"status": "ok"})
    })
    
    app.Listen(":8080")
}
Chi
package main

import (
    "net/http"
    "github.com/go-chi/chi/v5"
    "github.com/victorximenis/logger"
    "github.com/victorximenis/logger/middlewares"
)

func main() {
    logger.InitWithProfile("production", "api-service")
    
    r := chi.NewRouter()
    
    // Adicionar middleware de logging
    r.Use(middlewares.ChiLogger())
    
    r.Get("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
        // O contexto já contém correlation_id, request_id, etc.
        logger.Info(r.Context()).
            Str("user_id", chi.URLParam(r, "id")).
            Msg("User requested")
        
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"status": "ok"}`))
    })
    
    http.ListenAndServe(":8080", r)
}
4. Integração com PostgreSQL (PGX)
package main

import (
    "context"
    "github.com/jackc/pgx/v5/pgxpool"
    "github.com/victorximenis/logger"
    "github.com/victorximenis/logger/integrations"
)

func main() {
    logger.InitWithProfile("production", "db-service")
    
    // Configurar pool de conexões com logging
    config, err := pgxpool.ParseConfig("postgres://user:pass@localhost/db")
    if err != nil {
        panic(err)
    }
    
    // Adicionar tracer de logging
    config.ConnConfig.Tracer = integrations.NewPGXTracer()
    
    pool, err := pgxpool.NewWithConfig(context.Background(), config)
    if err != nil {
        panic(err)
    }
    defer pool.Close()
    
    // Todas as queries serão automaticamente logadas
    rows, err := pool.Query(context.Background(), "SELECT id, name FROM users WHERE active = $1", true)
    if err != nil {
        logger.Error(context.Background()).Err(err).Msg("Query failed")
        return
    }
    defer rows.Close()
    
    logger.Info(context.Background()).Msg("Query executed successfully")
}
5. Sanitização LGPD Automática
package main

import (
    "context"
    "github.com/victorximenis/logger"
)

func main() {
    logger.InitWithProfile("production", "user-service")
    
    ctx := context.Background()
    
    // Dados sensíveis são automaticamente sanitizados
    logger.Info(ctx).
        Str("email", "user@example.com").           // Será sanitizado: u***@e***.com
        Str("cpf", "123.456.789-00").              // Será sanitizado: 123.***.***-**
        Str("phone", "+55 11 99999-9999").         // Será sanitizado: +55 11 9****-****
        Str("credit_card", "4111 1111 1111 1111"). // Será sanitizado: 4111 **** **** ****
        Str("password", "mypassword").             // Será sanitizado: [REDACTED]
        Msg("User data processed")
}
6. Correlation IDs e Distributed Tracing
package main

import (
    "context"
    "github.com/victorximenis/logger"
    "github.com/victorximenis/logger/observability"
)

func main() {
    logger.InitWithProfile("production", "order-service")
    
    ctx := context.Background()
    
    // Adicionar correlation ID manualmente
    ctx = observability.ContextWithCorrelationID(ctx, "order-123")
    
    // Iniciar span do Datadog
    span := observability.StartSpan("process.order")
    defer span.Finish()
    ctx = observability.ContextWithSpan(ctx, span)
    
    // Logs incluirão automaticamente trace_id, span_id, correlation_id
    logger.Info(ctx).
        Str("order_id", "123").
        Float64("amount", 99.99).
        Msg("Processing order")
    
    // Registrar métricas
    observability.IncrementCounter("orders.processed", []string{"status:success"})
    observability.RecordDuration("orders.processing_time", span.Duration(), []string{"service:order"})
}

Configuração de Observabilidade

Variáveis de Ambiente
Configurações Gerais
# Habilitar observabilidade
LOGGER_OBSERVABILITY_ENABLED=true
OBSERVABILITY_ENABLED=true
OBSERVABILITY_DATADOG=true
OBSERVABILITY_ELK=true
OBSERVABILITY_CORRELATION_ID=true
Datadog
# Configurações básicas
DD_ENABLED=true
DD_SERVICE=my-service
DD_ENV=production
DD_VERSION=1.0.0
DD_AGENT_HOST=localhost:8126

# Tracing e métricas
DD_TRACING_ENABLED=true
DD_METRICS_ENABLED=true
DD_TRACE_SAMPLE_RATE=0.1

# Tags globais
DD_TAGS=team:backend,region:us-east-1
ELK Stack
# Configurações básicas
ELK_ENABLED=true
ELK_SERVICE=my-service
ELK_ENV=production
ELK_SERVICE_VERSION=1.0.0

# Elasticsearch
ELK_INDEX_PREFIX=logs
ELK_ECS_MAPPING=true
ELK_HOSTNAME=my-host
ELK_DATACENTER=us-east-1

# Campos personalizados
ELK_CUSTOM_FIELDS=team=backend,region=us-east-1
Perfis de Configuração
Produção
// Configuração automática para produção
config := logger.NewProductionConfig("my-service")
// - LogLevel: INFO
// - PrettyPrint: false
// - CallerEnabled: false
// - Datadog: habilitado (sampling 10%)
// - ELK: habilitado (ECS mapping)
// - CorrelationID: habilitado
Desenvolvimento
// Configuração automática para desenvolvimento
config := logger.NewDevelopmentConfig("my-service")
// - LogLevel: DEBUG
// - PrettyPrint: true
// - CallerEnabled: true
// - Datadog: desabilitado
// - ELK: habilitado (formato simples)
// - CorrelationID: habilitado
Staging
// Configuração automática para staging
config := logger.NewStagingConfig("my-service")
// - LogLevel: DEBUG
// - PrettyPrint: false
// - CallerEnabled: true
// - Datadog: habilitado
// - ELK: habilitado (ECS mapping)
// - CorrelationID: habilitado

Adapter Zerolog Avançado

Configuração Completa
package main

import (
    "os"
    "github.com/victorximenis/logger"
    "github.com/victorximenis/logger/adapters"
    "github.com/victorximenis/logger/core"
)

func main() {
    // Configuração avançada do Zerolog
    config := &adapters.ZerologConfig{
        Writer:        os.Stdout,
        Level:         core.INFO,
        TimeFormat:    "", // Unix timestamp
        PrettyPrint:   false,
        CallerEnabled: false,
    }
    
    // Criar adapter e logger
    adapter := adapters.NewZerologAdapter(config)
    log := logger.New(adapter)
    
    // Logger com campos pré-definidos
    serviceLogger := log.WithFields(map[string]interface{}{
        "service": "auth",
        "version": "1.0.0",
    })
    
    ctx := context.Background()
    serviceLogger.Info(ctx).
        Str("user_id", "123").
        Int("attempt", 1).
        Msg("User login successful")
}
Diferentes Tipos de Campos
log.Info(ctx).
    Str("string_field", "value").           // Campo string
    Int("int_field", 42).                   // Campo inteiro
    Float64("float_field", 3.14).           // Campo float64
    Bool("bool_field", true).               // Campo booleano
    Err(errors.New("example error")).       // Campo de erro
    Any("any_field", customStruct).         // Campo de qualquer tipo
    Fields(map[string]interface{}{          // Múltiplos campos
        "key1": "value1",
        "key2": "value2",
    }).
    Msg("Log with various field types")
Formatação de Mensagens
// Mensagem simples
log.Info(ctx).Msg("Simple message")

// Mensagem formatada
log.Info(ctx).Msgf("User %s has %d points", "John", 100)

// Apenas campos sem mensagem
log.Info(ctx).Str("event", "user_action").Send()

Níveis de Log

O pacote suporta os seguintes níveis de log:

  • DEBUG: Informações detalhadas de depuração
  • INFO: Mensagens informativas gerais
  • WARN: Situações que merecem atenção
  • ERROR: Erros que não impedem a execução
  • FATAL: Erros críticos que impedem a execução

Arquitetura

Interfaces Principais
LoggerAdapter

Interface que deve ser implementada por diferentes bibliotecas de logging:

type LoggerAdapter interface {
    Log(ctx context.Context, level Level, msg string, fields map[string]interface{})
    WithContext(ctx context.Context) LoggerAdapter
    IsLevelEnabled(level Level) bool
}
Logger

Interface pública para operações de logging:

type Logger interface {
    Debug(ctx context.Context) LogEvent
    Info(ctx context.Context) LogEvent
    Warn(ctx context.Context) LogEvent
    Error(ctx context.Context) LogEvent
    Fatal(ctx context.Context) LogEvent
    WithContext(ctx context.Context) Logger
    WithFields(fields map[string]interface{}) Logger
}
LogEvent

Interface para construção fluente de entradas de log:

type LogEvent interface {
    Str(key, val string) LogEvent
    Int(key string, val int) LogEvent
    Float64(key string, val float64) LogEvent
    Bool(key string, val bool) LogEvent
    Err(err error) LogEvent
    Any(key string, val interface{}) LogEvent
    Fields(fields map[string]interface{}) LogEvent
    Msg(msg string)
    Msgf(format string, args ...interface{})
    Send()
}

Componentes Disponíveis

Adapters
  • ZerologAdapter: Implementação completa usando zerolog
  • DatadogLoggerAdapter: Wrapper para integração com Datadog
  • ELKLoggerAdapter: Wrapper para integração com ELK Stack
  • MultiObservabilityAdapter: Combina múltiplos adapters
  • CorrelationIDAdapter: Adiciona correlation IDs automáticos
Middlewares HTTP
  • GinLogger: Middleware para framework Gin
  • FiberLogger: Middleware para framework Fiber
  • ChiLogger: Middleware para framework Chi
Integrações
  • PGXTracer: Tracer para logging de queries PostgreSQL via PGX
Sanitização
  • LGPDSanitizer: Sanitização automática de dados sensíveis conforme LGPD
Observabilidade
  • Datadog: Distributed tracing, métricas e dashboards
  • ELK Stack: Logs estruturados com Elastic Common Schema (ECS)
  • Correlation IDs: Rastreamento de requisições entre serviços

Exemplos de Adapters para Outras Bibliotecas

Adapter para Logrus
import "github.com/sirupsen/logrus"

type LogrusAdapter struct {
    logger *logrus.Logger
}

func (l *LogrusAdapter) Log(ctx context.Context, level core.Level, msg string, fields map[string]interface{}) {
    entry := l.logger.WithFields(logrus.Fields(fields))
    
    switch level {
    case core.DEBUG:
        entry.Debug(msg)
    case core.INFO:
        entry.Info(msg)
    case core.WARN:
        entry.Warn(msg)
    case core.ERROR:
        entry.Error(msg)
    case core.FATAL:
        entry.Fatal(msg)
    }
}
Adapter para Zap
import "go.uber.org/zap"

type ZapAdapter struct {
    logger *zap.Logger
}

func (z *ZapAdapter) Log(ctx context.Context, level core.Level, msg string, fields map[string]interface{}) {
    zapFields := make([]zap.Field, 0, len(fields))
    for k, v := range fields {
        zapFields = append(zapFields, zap.Any(k, v))
    }
    
    switch level {
    case core.DEBUG:
        z.logger.Debug(msg, zapFields...)
    case core.INFO:
        z.logger.Info(msg, zapFields...)
    // ... outros níveis
    }
}

Monitoramento e Métricas

Dashboards Datadog

O sistema automaticamente envia métricas para Datadog:

  • logger.log_count: Contador de logs por nível
  • logger.error_count: Contador de erros
  • http.request.duration: Duração de requisições HTTP
  • http.request.count: Contador de requisições HTTP
  • db.query.duration: Duração de queries de banco
  • db.query.count: Contador de queries de banco
Logs Estruturados ELK

Logs são enviados para Elasticsearch seguindo o padrão ECS:

{
  "@timestamp": "2024-01-15T10:30:00.000Z",
  "ecs.version": "8.0",
  "message": "User login successful",
  "log.level": "info",
  "service.name": "auth-service",
  "service.version": "1.0.0",
  "service.environment": "production",
  "host.name": "api-server-01",
  "user.id": "123",
  "trace.id": "abc123",
  "span.id": "def456",
  "http.request.method": "POST",
  "http.response.status_code": 200,
  "event.duration": 150000000
}

Testes

Execute os testes com:

go test ./...

Para executar com cobertura:

go test ./... -cover

Para executar exemplos:

go run examples/basic_usage.go
go run examples/middleware_example.go
go run examples/observability_example.go

Estrutura do Projeto

logger/
├── logger/
│   ├── core/              # Interfaces principais e tipos
│   │   ├── adapter.go     # Interface LoggerAdapter
│   │   ├── event.go       # Interface LogEvent
│   │   ├── level.go       # Níveis de log
│   │   └── output.go      # Gerenciamento de saída
│   ├── adapters/          # Implementações de adapters
│   │   └── zerolog.go     # Adapter para zerolog
│   ├── middlewares/       # Middlewares HTTP
│   │   ├── gin.go         # Middleware para Gin
│   │   ├── fiber.go       # Middleware para Fiber
│   │   └── chi.go         # Middleware para Chi
│   ├── integrations/      # Integrações com bancos de dados
│   │   └── pgx.go         # Integração com PostgreSQL via PGX
│   ├── observability/     # Sistema de observabilidade
│   │   ├── adapter.go     # Adapters de observabilidade
│   │   ├── datadog.go     # Integração com Datadog
│   │   └── elk.go         # Integração com ELK Stack
│   ├── sanitize/          # Sistema de sanitização LGPD
│   │   └── lgpd.go        # Sanitizador LGPD
│   ├── config.go          # Configuração do sistema
│   ├── logger.go          # Interface Logger principal
│   └── doc.go             # Documentação do pacote
├── examples/              # Exemplos de uso
│   ├── basic_usage.go
│   ├── middleware_example.go
│   └── observability_example.go
├── scripts/               # Scripts de configuração
├── tasks/                 # Documentação de tarefas
├── go.mod
└── README.md

Dependências

Principais
  • github.com/rs/zerolog - Biblioteca de logging principal
  • github.com/google/uuid - Geração de UUIDs para correlation IDs
Middlewares HTTP
  • github.com/gin-gonic/gin - Framework web Gin
  • github.com/gofiber/fiber/v2 - Framework web Fiber
  • github.com/go-chi/chi/v5 - Framework web Chi
Integração PostgreSQL
  • github.com/jackc/pgx/v5 - Driver PostgreSQL
Observabilidade
  • github.com/DataDog/datadog-go/v5/statsd - Cliente de métricas Datadog
  • gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer - Distributed tracing Datadog
Rotação de Logs
  • gopkg.in/natefinch/lumberjack.v2 - Rotação automática de arquivos de log

Contribuição

  1. Faça um fork do projeto
  2. Crie uma branch para sua feature (git checkout -b feature/nova-feature)
  3. Commit suas mudanças (git commit -am 'Adiciona nova feature')
  4. Push para a branch (git push origin feature/nova-feature)
  5. Abra um Pull Request

Licença

Este projeto está licenciado sob a licença MIT - veja o arquivo LICENSE para detalhes.

Documentation

Overview

Package logger fornece uma interface unificada para logging estruturado que pode ser implementada por diferentes bibliotecas de logging.

O pacote utiliza o padrão Adapter para permitir que diferentes implementações de logging (como logrus, zap, slog, etc.) sejam utilizadas através de uma interface comum, com suporte completo a observabilidade, middlewares HTTP e conformidade LGPD.

Características principais:

  • Interface fluente com method chaining
  • Suporte a logging estruturado com campos tipados
  • Níveis de log padrão (DEBUG, INFO, WARN, ERROR, FATAL)
  • Propagação de contexto
  • Campos pré-definidos por instância
  • Logger global thread-safe
  • Perfis de configuração pré-definidos (development, staging, production)
  • Observabilidade integrada (Datadog, ELK Stack)
  • Middlewares para frameworks HTTP (Gin, Fiber, Chi)
  • Integração com PostgreSQL via PGX
  • Sanitização LGPD automática
  • Correlation IDs e distributed tracing

Uso Básico

Inicialização rápida com perfis pré-configurados: 

// Inicialização para produção (Datadog + ELK habilitados)
err := logger.InitWithProfile("production", "my-service")
if err != nil {
	panic(err)
}

ctx := context.Background()

// Usar o logger global
logger.Info(ctx).
	Str("user_id", "123").
	Int("attempt", 1).
	Msg("User login successful")

Configuração Manual

Para configuração personalizada: 

config := logger.NewConfig()
config.ServiceName = "auth-service"
config.Environment = "production"
config.LogLevel = logger.INFO

// Habilitar observabilidade
config.Observability.Enabled = true
config.Observability.EnableDatadog = true
config.Observability.EnableELK = true

err := logger.Init(config)
if err != nil {
	panic(err)
}

Logger com Campos Pré-definidos

Criar instâncias com campos comuns: 

// Logger com campos comuns
userLogger := logger.WithFields(map[string]interface{}{
	"service": "auth",
	"version": "1.0.0",
})

// Todos os logs incluirão os campos pré-definidos
userLogger.Error(ctx).
	Err(err).
	Msg("Authentication failed")

Middlewares HTTP

O pacote inclui middlewares para frameworks populares: 

// Gin
r.Use(middlewares.GinLogger())

// Fiber
app.Use(middlewares.FiberLogger())

// Chi
r.Use(middlewares.ChiLogger())

Implementando um Adapter Personalizado

Para implementar um novo adapter, implemente a interface core.LoggerAdapter: 

type MyAdapter struct {
	// campos necessários
}

func (a *MyAdapter) Log(ctx context.Context, level core.Level, msg string, fields map[string]interface{}) {
	// implementação específica
}

func (a *MyAdapter) WithContext(ctx context.Context) core.LoggerAdapter {
	// retornar nova instância com contexto
}

func (a *MyAdapter) IsLevelEnabled(level core.Level) bool {
	// verificar se o nível está habilitado
}

Configuração via Variáveis de Ambiente

O pacote suporta configuração através de variáveis de ambiente:

  • LOGGER_SERVICE_NAME: Nome do serviço
  • LOGGER_ENVIRONMENT: Ambiente (development, staging, production)
  • LOGGER_LOG_LEVEL: Nível de log (debug, info, warn, error, fatal)
  • LOGGER_OUTPUT: Tipo de saída (stdout, file)
  • LOGGER_PRETTY_PRINT: Formatação legível (true/false)
  • LOGGER_OBSERVABILITY_ENABLED: Habilitar observabilidade (true/false)

Para carregar configuração do ambiente: 

err := logger.InitFromEnv()
if err != nil {
	panic(err)
}

Observabilidade

O pacote inclui integração nativa com sistemas de observabilidade:

  • Datadog APM para distributed tracing
  • ELK Stack para agregação de logs
  • Correlation IDs automáticos
  • Métricas de performance
  • Dashboards pré-configurados

Conformidade LGPD

Sanitização automática de dados sensíveis:

  • CPF, CNPJ, emails, telefones
  • Dados de cartão de crédito
  • Senhas e tokens
  • Configuração flexível de campos sensíveis

Index

Constants

View Source 
const (
	// DefaultServiceName é o nome padrão do serviço
	DefaultServiceName = "unknown-service"
	// DefaultEnvironment é o ambiente padrão
	DefaultEnvironment = "development"
	// DefaultLogLevel é o nível de log padrão
	DefaultLogLevel = core.INFO
	// DefaultLogFilePath é o caminho padrão do arquivo de log
	DefaultLogFilePath = "/var/log/app.log"
	// DefaultOutput é o tipo de saída padrão
	DefaultOutput = OutputStdout
)

Constantes para valores padrão

View Source 
const (
	// EnvServiceName é o nome da variável de ambiente para o nome do serviço
	EnvServiceName = "LOGGER_SERVICE_NAME"
	// EnvEnvironment é o nome da variável de ambiente para o ambiente
	EnvEnvironment = "LOGGER_ENVIRONMENT"
	// EnvOutput é o nome da variável de ambiente para o tipo de saída
	EnvOutput = "LOGGER_OUTPUT"
	// EnvLogLevel é o nome da variável de ambiente para o nível de log
	EnvLogLevel = "LOGGER_LOG_LEVEL"
	// EnvLogFilePath é o nome da variável de ambiente para o caminho do arquivo de log
	EnvLogFilePath = "LOGGER_LOG_FILE_PATH"
	// EnvTenantID é o nome da variável de ambiente para o tenant ID
	EnvTenantID = "LOGGER_TENANT_ID"
	// EnvPrettyPrint é o nome da variável de ambiente para pretty print
	EnvPrettyPrint = "LOGGER_PRETTY_PRINT"
	// EnvCallerEnabled é o nome da variável de ambiente para habilitar caller
	EnvCallerEnabled = "LOGGER_CALLER_ENABLED"
	// EnvObservabilityEnabled é o nome da variável de ambiente para habilitar observabilidade
	EnvObservabilityEnabled = "LOGGER_OBSERVABILITY_ENABLED"
)

Constantes para nomes de variáveis de ambiente

Variables

This section is empty.

Functions

func Debug 

func Debug(ctx context.Context) core.LogEvent

Debug retorna um LogEvent para nível DEBUG usando o logger global

func Error 

func Error(ctx context.Context) core.LogEvent

Error retorna um LogEvent para nível ERROR usando o logger global

func Fatal 

func Fatal(ctx context.Context) core.LogEvent

Fatal retorna um LogEvent para nível FATAL usando o logger global

func Info 

func Info(ctx context.Context) core.LogEvent

Info retorna um LogEvent para nível INFO usando o logger global

func Init 

func Init(config Config) error

Init inicializa o logger global com a configuração especificada Esta função é thread-safe e pode ser chamada múltiplas vezes

func InitFromEnv 

func InitFromEnv() error

InitFromEnv inicializa o logger global carregando a configuração de variáveis de ambiente

func InitWithObservability 

func InitWithObservability(serviceName, environment string, enableDatadog, enableELK bool) error

InitWithObservability inicializa o logger com observabilidade habilitada

func InitWithProfile 

func InitWithProfile(profile string, serviceName string) error

InitWithProfile inicializa o logger com um perfil específico

func IsInitialized 

func IsInitialized() bool

IsInitialized retorna true se o logger global foi inicializado

func Warn 

func Warn(ctx context.Context) core.LogEvent

Warn retorna um LogEvent para nível WARN usando o logger global

Types

type Config 

type Config struct {
	// ServiceName é o nome do serviço que está gerando os logs
	ServiceName string
	// Environment é o ambiente onde o serviço está executando (development, staging, production)
	Environment string
	// Output define onde os logs serão direcionados (stdout, file, ou ambos)
	Output OutputType
	// LogLevel define o nível mínimo de log que será registrado
	LogLevel core.Level
	// LogFilePath define o caminho do arquivo de log quando Output inclui OutputFile
	LogFilePath string
	// TenantID é um identificador opcional para multi-tenancy
	TenantID string
	// PrettyPrint habilita formatação legível para desenvolvimento
	PrettyPrint bool
	// CallerEnabled habilita informações do caller nos logs
	CallerEnabled bool
	// Observability define as configurações de observabilidade
	Observability observability.ObservabilityConfig
}

Config define a configuração do sistema de logging

func GetConfig 

func GetConfig() Config

GetConfig retorna a configuração atual do logger global

func LoadConfigFromEnv 

func LoadConfigFromEnv() Config

LoadConfigFromEnv carrega a configuração a partir de variáveis de ambiente com fallback para valores padrão quando as variáveis não estão definidas

func LoadConfigFromEnvWithValidation 

func LoadConfigFromEnvWithValidation() (Config, error)

LoadConfigFromEnvWithValidation carrega a configuração de variáveis de ambiente e valida os valores carregados, retornando erro se a configuração for inválida

func NewConfig 

func NewConfig() Config

NewConfig cria uma nova configuração com valores padrão

func NewDevelopmentConfig 

func NewDevelopmentConfig(serviceName string) Config

NewDevelopmentConfig cria uma configuração otimizada para desenvolvimento

func NewProductionConfig 

func NewProductionConfig(serviceName string) Config

NewProductionConfig cria uma configuração otimizada para produção

func NewStagingConfig 

func NewStagingConfig(serviceName string) Config

NewStagingConfig cria uma configuração otimizada para staging

func (Config) String 

func (c Config) String() string

String retorna uma representação em string da configuração para debugging

func (Config) Validate 

func (c Config) Validate() error

Validate verifica se a configuração é válida

type Logger 

type Logger interface {
	// Debug cria uma entrada de log de nível DEBUG.
	// Usado para informações detalhadas de depuração que normalmente
	// só são de interesse ao diagnosticar problemas.
	Debug(ctx context.Context) core.LogEvent

	// Info cria uma entrada de log de nível INFO.
	// Usado para mensagens informativas gerais que destacam
	// o progresso da aplicação em um nível grosso.
	Info(ctx context.Context) core.LogEvent

	// Warn cria uma entrada de log de nível WARN.
	// Usado para situações potencialmente prejudiciais que
	// merecem atenção mas não impedem a execução.
	Warn(ctx context.Context) core.LogEvent

	// Error cria uma entrada de log de nível ERROR.
	// Usado para eventos de erro que ainda permitem que
	// a aplicação continue executando.
	Error(ctx context.Context) core.LogEvent

	// Fatal cria uma entrada de log de nível FATAL.
	// Usado para erros muito severos que provavelmente
	// levarão à terminação da aplicação.
	Fatal(ctx context.Context) core.LogEvent

	// WithContext retorna uma nova instância do logger com o contexto especificado.
	// Útil para propagar informações de contexto através de chamadas de log.
	WithContext(ctx context.Context) Logger

	// WithFields retorna uma nova instância do logger com campos pré-definidos.
	// Útil para adicionar campos comuns que serão incluídos em todas as entradas de log.
	WithFields(fields map[string]interface{}) Logger
}

Logger define a interface pública para operações de logging. Esta interface fornece métodos para diferentes níveis de log e suporta method chaining através da interface LogEvent.

Exemplo de uso: 

logger.Info(ctx).
	Str("user_id", "123").
	Int("attempt", 1).
	Msg("User login successful")

func GetLogger 

func GetLogger() Logger

GetLogger retorna o logger global. Se não foi inicializado, inicializa com configuração padrão

func New 

func New(adapter LoggerAdapter) Logger

New cria uma nova instância de Logger usando o adapter especificado. O adapter é responsável pela implementação real do logging.

Exemplo: 

adapter := &MyLoggerAdapter{}
log := logger.New(adapter)

func WithContext 

func WithContext(ctx context.Context) Logger

WithContext retorna um novo logger global com contexto

func WithFields 

func WithFields(fields map[string]interface{}) Logger

WithFields retorna um novo logger global com campos pré-definidos

type LoggerAdapter 

type LoggerAdapter = core.LoggerAdapter

LoggerAdapter é um alias para core.LoggerAdapter para facilitar o uso

type OutputType 

type OutputType int

OutputType define os tipos de saída de log disponíveis 

const (
	// OutputStdout direciona logs para stdout
	OutputStdout OutputType = 1 << iota
	// OutputFile direciona logs para arquivo
	OutputFile
)

func (OutputType) String 

func (o OutputType) String() string

String retorna a representação em string do tipo de saída

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.