Что такое Observability?

# Observability: концепция и инструменты для разработчика Go

Что такое Observability?

Observability (наблюдаемость) — это системное свойство, позволяющее понять внутреннее состояние системы по её внешним выходным данным. Это более глубокое понятие чем просто мониторинг или сбор логов.

Мониторинг отвечает на вопросы "что случилось?", а observability — на вопросы "почему это случилось?" и "как исправить?". В контексте разработки Go это означает набор практик и инструментов для понимания поведения приложения в реальных условиях, диагностики проблем и обеспечения надёжности системы.

Ключевые компоненты Observability

1. Метрики (Metrics) — количественные данные о системе (загрузка CPU, память, количество запросов, latency)
2. Логи (Logs) — детализированные события с временными метками и контекстом
3. Трейсы (Traces) — распределённое отслеживание выполнения операций через разные компоненты системы

Observability в Go: практическая реализация

Инструменты и библиотеки для Go

// Пример конфигурации Observability инструментов в Go
package main

import (
    "context"
    "log"
    "net/http"
    "time"
    
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/prometheus"
    "go.opentelemetry.io/otel/metric/global"
    "go.opentelemetry.io/otel/sdk/metric"
    "go.opentelemetry.io/otel/trace"
    prometheusclient "github.com/prometheus/client_golang/prometheus"
    "go.uber.org/zap"
)

Сбор метрик с Prometheus и OpenTelemetry

Prometheus — стандартный инструмент для метрик в Go. Используйте библиотеку prometheus/client_golang:

// Создание и регистрация метрик
var (
    requestCounter = prometheusclient.NewCounterVec(
        prometheusclient.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests",
        },
        []string{"method", "path", "status"},
    )
    requestDuration = prometheusclient.NewHistogramVec(
        prometheusclient.HistogramOpts{
            Name: "http_request_duration_seconds",
            Help: "Duration of HTTP requests",
        },
        []string{"method", "path"},
    )
)

func init() {
    prometheusclient.MustRegister(requestCounter)
    prometheusclient.MustRegister(requestDuration)
}

func handler(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    
    // Логика обработки запроса
    
    duration := time.Since(start).Seconds()
    requestDuration.WithLabelValues(r.Method, r.URL.Path).Observe(duration)
    requestCounter.WithLabelValues(r.Method, r.URL.Path, "200").Inc()
}

Распределённое трассирование с OpenTelemetry

OpenTelemetry — современный стандарт для трассирования. Go имеет официальную поддержку:

// Инициализация трассирования
func initTracer() {
    exporter, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint("http://jaeger:14268/api/traces")))
    if err != nil {
        log.Fatal(err)
    }
    
    tp := trace.NewTracerProvider(
        trace.WithBatcher(exporter),
        trace.WithResource(resource.NewWithAttributes(
            semconv.SchemaURL,
            semconv.ServiceNameKey.String("my-go-service"),
        )),
    )
    otel.SetTracerProvider(tp)
}

// Использование трассирования в обработчике
func tracedHandler(ctx context.Context, req *Request) (*Response, error) {
    tracer := otel.Tracer("my-tracer")
    
    ctx, span := tracer.Start(ctx, "handle-request")
    defer span.End()
    
    // Логика обработки
    span.AddEvent("processing started")
    
    // Добавление атрибутов к трейсу
    span.SetAttributes(
        attribute.String("request_id", req.ID),
        attribute.Int("user_id", req.UserID),
    )
    
    return processRequest(ctx, req)
}

Структурированные логи с Zap или Logrus

Для observability критически важно использовать структурированные логи с контекстом:

// Использование Zap для структурированных логов
logger, _ := zap.NewProduction()
defer logger.Sync()

func processOrder(ctx context.Context, orderID string) {
    logger.Info("processing order",
        zap.String("order_id", orderID),
        zap.String("trace_id", trace.SpanContextFromContext(ctx).TraceID().String()),
        zap.Time("start_time", time.Now()),
        zap.String("service", "order-service"),
    )
    
    // Логика обработки
    
    logger.Info("order processed successfully",
        zap.String("order_id", orderID),
        zap.Duration("processing_time", time.Since(start)),
        zap.Int("items_count", len(items)),
    )
}

Best Practices для Observability в Go

1. Контекст всегда в логах и метриках

   • Включайте trace_id, span_id для корреляции данных
   • Добавляйте бизнес-контекст (user_id, order_id, etc.)

2. Инструментируйте на уровне middleware

   • HTTP middleware для автоматического трассирования и метрик
   • GRPC interceptors для распределённых систем

// HTTP middleware для observability
func ObservabilityMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // Создание или продолжение трейса
        tracer := otel.Tracer("http")
        ctx, span := tracer.Start(r.Context(), "http-request")
        defer span.End()
        
        // Добавление атрибутов
        span.SetAttributes(
            attribute.String("http.method", r.Method),
            attribute.String("http.path", r.URL.Path),
            attribute.String("http.user_agent", r.UserAgent()),
        )
        
        // Метрики
        requestCounter.WithLabelValues(r.Method, r.URL.Path).Inc()
        
        // Продолжение обработки с контекстом
        r = r.WithContext(ctx)
        next.ServeHTTP(w, r)
        
        duration := time.Since(start).Seconds()
        requestDuration.WithLabelValues(r.Method, r.URL.Path).Observe(duration)
    })
}

1. Агрегируйте и коррелируйте данные

   • Используйте инструменты как Grafana для визуализации
   • Коррелируйте метрики, логи и трейсы через общие идентификаторы

2. Инструментируйте ошибки глубоко

   • Не просто "error occurred", а с контекстом и stack trace
   • Используйте structured errors с дополнительными полями

// Структурированные ошибки с контекстом observability
type ObservabilityError struct {
    Err      error
    TraceID  string
    SpanID   string
    Service  string
    UserID   string
    Timestamp time.Time
}

func (oe *ObservabilityError) Error() string {
    return fmt.Sprintf("error in %s: %v (trace: %s)", oe.Service, oe.Err, oe.TraceID)
}

func (oe *ObservabilityError) LogFields() []zap.Field {
    return []zap.Field{
        zap.String("trace_id", oe.TraceID),
        zap.String("span_id", oe.SpanID),
        zap.String("service", oe.Service),
        zap.String("user_id", oe.UserID),
        zap.Time("timestamp", oe.Timestamp),
        zap.Error(oe.Err),
    }
}

Почему Observability критична для Go разработчиков?

1. Распределённые системы: микросервисные архитектуры требуют observability для понимания взаимодействий
2. Высокая конкуренция: Go часто используется в высоконагруженных системах где проблемы сложнее диагностировать
3. Асинхронная обработка: goroutines и channels требуют специального инструментирования для понимания потоков данных
4. Производительность: метрики помогают оптимизировать использование памяти и CPU в runtime Go

Резюме

Observability — это не просто набор инструментов, а культура разработки и эксплуатации систем. Для Go разработчика это означает:

• Инструментирование приложения с самого начала
• Использование стандартов (OpenTelemetry, Prometheus)
• Структурированные логи с контекстом
• Корреляция данных между метриками, логами и трейсами
• Автоматизация сборки и анализа данных через middleware

При правильной реализации observability позволяет не только быстро находить проблемы, но также предсказывать их, понимать поведение системы в целом и постоянно улучшать её надёжность и производительность.