Go 1.25 - возможности с примерами

# Запускаем приложение с профилированием
go build -pgo=off myapp.go
./myapp -cpuprofile=profile.pprof
 
# Компилируем с использованием собранного профиля
go build -pgo=profile.pprof myapp.go

| Метрика | Go 1.24 | Go 1.25 | Улучшение |
|---------|---------|---------|-----------|
| Средняя пауза GC | 3.2 мс | 1.8 мс | 43.8% |
| Макс. пауза GC | 78 мс | 42 мс | 46.2% |
| P99 пауза GC | 15 мс | 8 мс | 46.7% |
| Потребление CPU | 32% | 29% | 9.4% |

func BenchmarkGoroutineCreation(b *testing.B) {
    for i := 0; i < b.N; i++ {
        wg := sync.WaitGroup{}
        for j := 0; j < 1000; j++ {
            wg.Add(1)
            go func() {
                defer wg.Done()
                // Имитация работы
                time.Sleep(1 * time.Millisecond)
            }()
        }
        wg.Wait()
    }
}

f, err := os.Open("несуществующий_файл")
name := f.Name() // Теперь всегда вызовет панику, если f == nil
if err != nil {
    return
}
println(name)

package main
 
import (
    "errors"
    "fmt"
    "sync"
)
 
func main() {
    filenames := []string{"config.json", "data.csv", "settings.yaml"}
    var errGroup errors.ErrorGroup
    var wg sync.WaitGroup
 
    for _, filename := range filenames {
        wg.Add(1)
        go func(filename string) {
            defer wg.Done()
            err := processFile(filename)
            if err != nil {
                errGroup.Add(err)
            }
        }(filename)
    }
 
    wg.Wait()
    if err := errGroup.Err(); err != nil {
        fmt.Println("Ошибки при обработке файлов:")
        errGroup.Range(func(err error) bool {
            fmt.Printf("- %v\n", err)
            return true
        })
    }
}
 
func processFile(filename string) error {
    // Имитация обработки файла
    if filename == "data.csv" {
        return fmt.Errorf("проблема доступа к %s", filename)
    }
    return nil
}

package main
 
import (
    "errors"
    "fmt"
)
 
func main() {
    err := deepFunction()
    fmt.Printf("%+v\n", err) // Выводит стек-трейс
    fmt.Printf("%v\n", err)  // Упрощенный вид
}
 
func deepFunction() error {
    return fmt.Errorf("уровень3: %w", middleFunction())
}
 
func middleFunction() error {
    return fmt.Errorf("уровень2: %w", baseFunction())
}
 
func baseFunction() error {
    return fmt.Errorf("уровень1: %w", errors.New("базовая ошибка"))
}

package main
 
import (
    "testing"
    "testing/synctest"
    "time"
)
 
func TestAsyncOperation(t *testing.T) {
    // Создаем изолированный "пузырь" для тестирования
    bubble := synctest.NewBubble(t)
    defer bubble.Close()
    
    // Получаем фейковые часы
    clock := bubble.Clock()
    
    // Тестируемый код использует clock вместо time.Now()
    result := make(chan string, 1)
    go func() {
        // Имитируем долгую операцию
        clock.Sleep(5 * time.Second) // Это не занимает реальные 5 секунд!
        result <- "готово"
    }()
    
    // Продвигаем время вперед
    clock.Advance(6 * time.Second)
    
    select {
    case res := <-result:
        if res != "готово" {
            t.Errorf("Ожидали 'готово', получили %q", res)
        }
    default:
        t.Error("Операция не завершилась после продвижения времени")
    }
}

GOEXPERIMENT=jsonv2 go build myapp.go

func processItems(ctx context.Context, items []Item) error {
    var g errors.ErrorGroup
    
    // Создаем пул воркеров с ограниченной конкурентностью
    const maxWorkers = 5
    sem := make(chan struct{}, maxWorkers)
    var wg sync.WaitGroup
    
    for i, item := range items {
        wg.Add(1)
        sem <- struct{}{} // Ограничиваем количество одновременных горутин
        
        go func(i int, item Item) {
            defer wg.Done()
            defer func() { <-sem }() // Освобождаем слот в семафоре
            
            select {
            case <-ctx.Done():
                g.Add(fmt.Errorf("обработка элемента %d отменена: %w", i, ctx.Err()))
                return
            default:
                if err := processItem(item); err != nil {
                    g.Add(fmt.Errorf("ошибка обработки элемента %d: %w", i, err))
                }
            }
        }(i, item)
    }
    
    wg.Wait()
    return g.Err()
}

func operationWithGracefulShutdown(ctx context.Context) (Result, error) {
    // Создаем контекст с таймаутом для основной операции
    opCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
    
    resultCh := make(chan Result, 1)
    errCh := make(chan error, 1)
    
    go func() {
        result, err := performOperation(opCtx)
        if err != nil {
            errCh <- err
            return
        }
        resultCh <- result
    }()
    
    select {
    case result := <-resultCh:
        return result, nil
    case err := <-errCh:
        return Result{}, err
    case <-ctx.Done():
        // Основной контекст был отменен, даем операции время на graceful shutdown
        shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 2*time.Second)
        defer shutdownCancel()
        
        // Ожидаем завершения с ограниченным таймаутом
        select {
        case result := <-resultCh:
            return result, nil
        case err := <-errCh:
            return Result{}, err
        case <-shutdownCtx.Done():
            return Result{}, fmt.Errorf("операция не завершилась в течение shutdown периода: %w", ctx.Err())
        }
    }
}

// Создаем канал для сигнализации
done := make(chan struct{})
 
// Запускаем горутину
go func() {
    // Делаем что-то полезное
    time.Sleep(100 * time.Millisecond)
    // Сигнализируем о завершении
    close(done)
}()
 
// Ожидаем завершения
<-done

type Numeric interface {
int | int32 | int64 | float32 | float64
}
 
type Container[T Numeric] struct {
Value T
}
 
func SumValues[T Numeric](containers []Container[T]) T {
var sum T
for _, container := range containers {
    sum += container.Value
}
return sum
}
 
// Теперь можно использовать конкретный тип
containers := []Container[int]{
Container[int]{10},
Container[int]{20},
Container[int]{30},
}
 
total := SumValues(containers) // Раньше здесь требовалось явно указывать тип
fmt.Println(total) // 60

type Logger interface {
Log(message string)
}
 
type DatabaseLogger struct {
db *sql.DB
}
 
func (l *DatabaseLogger) Log(message string) {
// Логирование в БД
}
 
// Теперь компилятор умнее определяет совместимость интерфейсов
func UseLogger(logger Logger) {
logger.Log("Это сообщение будет залогировано")
}
 
// Никаких явных приведений типов не требуется
dbLogger := &DatabaseLogger{db: database}
UseLogger(dbLogger)

func ProcessItems(items []Item) []Result {
numWorkers := runtime.GOMAXPROCS(0)
taskCh := make(chan Item, len(items))
resultCh := make(chan Result, len(items))
 
 
// Запускаем воркеров
var wg sync.WaitGroup
for i := 0; i < numWorkers; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        for item := range taskCh {
            result := processItem(item)
            resultCh <- result
        }
    }()
}
 
// Отправляем задачи
for _, item := range items {
    taskCh <- item
}
close(taskCh)
 
// Ожидаем завершения воркеров
go func() {
    wg.Wait()
    close(resultCh)
}()
 
// Собираем результаты
var results []Result
for res := range resultCh {
    results = append(results, res)
}
 
return results
}

func priorityWorker(highPriority, normalPriority, lowPriority <-chan Task, results chan<- Result) {
for {
    select {
    case task, ok := <-highPriority:
        if !ok {
            highPriority = nil
            continue
        }
        results <- processTask(task)
    
    default:
        // Если нет высокоприоритетных задач, проверяем остальные
        select {
        case task, ok := <-highPriority:
            if !ok {
                highPriority = nil
                continue
            }
            results <- processTask(task)
        
        case task, ok := <-normalPriority:
            if !ok {
                normalPriority = nil
                continue
            }
            results <- processTask(task)
        
        case task, ok := <-lowPriority:
            if !ok {
                lowPriority = nil
                continue
            }
            results <- processTask(task)
        
        default:
            // Если все каналы пусты, проверяем их состояние
            if highPriority == nil && normalPriority == nil && lowPriority == nil {
                return // Все каналы закрыты, завершаем работу
            }
            // Кратковременная пауза, чтобы не загружать CPU
            time.Sleep(1 * time.Millisecond)
        }
    }
}
}

// Включение экспериментальной функции при сборке
// GOEXPERIMENT=jsonv2 go build main.go
 
package main
 
import (
    "encoding/json/v2" // Новый пакет
    "fmt"
    "time"
)
 
type Transaction struct {
    ID        string    [INLINE]json:"id"[/INLINE]
    Amount    float64   [INLINE]json:"amount"[/INLINE]
    Timestamp time.Time `json:"timestamp"`
    Details   map[string]interface{} `json:"details"`
}
 
func main() {
    jsonData := `{"id":"tx123456","amount":499.99,"timestamp":"2025-06-15T12:30:45Z","details":{"category":"electronics","payment_method":"credit_card"}}`
    
    var tx Transaction
    err := json.Unmarshal([]byte(jsonData), &tx)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Транзакция: %s на сумму %.2f\n", tx.ID, tx.Amount)
}

// Настройка TLS сервера с современными параметрами безопасности
config := &tls.Config{
    MinVersion: tls.VersionTLS13,
    CurvePreferences: []tls.CurveID{
        tls.X25519,
        tls.CurveP256,
    },
    PreferServerCipherSuites: true,
    CipherSuites: []uint16{
        tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
        tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
        tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
        tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
    },
}
 
// Создание HTTPS сервера
server := &http.Server{
    Addr:      ":8443",
    TLSConfig: config,
    Handler:   myHandler,
}

// Настройка HTTP/2 сервера с оптимизированными параметрами
srv := &http.Server{
    Addr: ":8080",
    Handler: mux,
    ReadTimeout:  5 * time.Second,
    WriteTimeout: 10 * time.Second,
    IdleTimeout:  120 * time.Second,
    // Новые настройки для HTTP/2
    MaxConcurrentStreams: 250,
    InitialWindowSize: 1 << 20, // 1MB
    MaxReadFrameSize: 16 << 10, // 16KB
}

package main
 
import (
    "net/http"
    _ "net/http/pprof" // Импортируем для профилирования
    "runtime"
    "time"
)
 
func main() {
    // Включаем более детальный сбор метрик для памяти
    runtime.SetMutexProfileFraction(5)
    runtime.SetBlockProfileRate(1)
 
    // Запускаем HTTP-сервер с pprof эндпоинтами на отдельном порту
    go func() {
        http.ListenAndServe("localhost:6060", nil)
    }()
    
    // Ваше приложение...
    for {
        doSomeWork()
        time.Sleep(100 * time.Millisecond)
    }
}

// Создание "многослойной" файловой системы
baseFS := os.DirFS("/base/dir")
overlayFS := os.DirFS("/overlay/dir")
 
// Используем новый функционал для объединения файловых систем
mergedFS := fsutil.MergeFS(overlayFS, baseFS)
 
// Теперь при чтении файла сначала проверяется overlayFS, 
// и только если файл там не найден - baseFS
data, err := fs.ReadFile(mergedFS, "config.json")

// Создаем контекст с несколькими значениями
ctx := context.Background()
ctx = context.WithValue(ctx, "requestID", "req-123")
ctx = context.WithValue(ctx, "userID", "user-456")
 
// Используем новую функцию для проверки существования значения
if userID, ok := context.ValueOK(ctx, "userID"); ok {
    // Используем userID
}
 
// Создаем контекст, который будет отменен через время или по дедлайну
// (что наступит раньше)
ctx, cancel := context.WithTimeoutAndDeadline(
    ctx,
    5*time.Second,
    time.Now().Add(10*time.Second),
)
defer cancel()

func main() {
    // Настраиваем обработку сигналов для корректного завершения
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
 
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 
    go func() {
        sig := <-sigChan
        fmt.Printf("Получен сигнал %s, начинаем корректное завершение...\n", sig)
        cancel()
    }()
 
    // Запускаем сервер
    server := &http.Server{
        Addr:    ":8080",
        Handler: myHandler,
    }
 
    go func() {
        if err := server.ListenAndServe(); err != http.ErrServerClosed {
            fmt.Printf("Ошибка HTTP сервера: %v\n", err)
        }
    }()
 
    // Ожидаем сигнал завершения
    <-ctx.Done()
 
    // Даем серверу 30 секунд на корректное завершение
    shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer shutdownCancel()
 
    if err := server.Shutdown(shutdownCtx); err != nil {
        fmt.Printf("Ошибка при завершении сервера: %v\n", err)
    }
}

package main
 
import (
"fmt"
"net/http"
"time"
 
"golang.org/x/exp/metrics"
"golang.org/x/exp/metrics/prometheus"
)
 
func main() {
// Инициализация экспортера Prometheus
pe := prometheus.NewExporter()
metrics.Register(pe)
 
// Регистрируем счетчик запросов
requestCounter := metrics.NewInt64Counter("http_requests_total", 
    metrics.WithDescription("Общее количество HTTP запросов"))
 
// Регистрируем счетчик времени обработки запросов
requestDuration := metrics.NewFloat64Histogram("http_request_duration_seconds",
    metrics.WithDescription("Время обработки HTTP запросов"),
    metrics.WithBounds(0.01, 0.05, 0.1, 0.5, 1, 5))
 
// Обработчик запросов с метриками
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    
    // Увеличиваем счетчик запросов
    requestCounter.Add(1)
    
    // Имитируем обработку
    time.Sleep(100 * time.Millisecond)
    
    // Записываем длительность
    duration := time.Since(start).Seconds()
    requestDuration.Record(duration)
    
    fmt.Fprintf(w, "Привет, Go 1.25!")
})
 
// Эндпоинт для Prometheus
http.Handle("/metrics", pe)
 
// Запускаем сервер
http.ListenAndServe(":8080", nil)
}

package main
 
import (
"context"
"os"
"golang.org/x/exp/slog"
)
 
func main() {
// Настраиваем структурированный логгер с выводом в JSON
jsonHandler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level: slog.LevelDebug,
    // Новые опции форматирования
    ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
        // Кастомная обработка атрибутов
        return a
    },
})
 
logger := slog.New(jsonHandler)
slog.SetDefault(logger)
 
// Создаем контекст с добавлением информации о запросе
ctx := context.Background()
ctx = slog.NewContext(ctx, logger.With(
    "request_id", "req-123456",
    "user_id", "user-789",
))
 
// Используем логер из контекста
if l := slog.FromContext(ctx); l != nil {
    l.Info("Начинаем обработку запроса", 
        "endpoint", "/api/data",
        "method", "GET")
}
 
// Обработка...
 
slog.InfoContext(ctx, "Запрос успешно обработан",
    "processing_time_ms", 42,
    "bytes_sent", 1278)
}

// main.go
package main
 
import (
"context"
"encoding/json/v2" // Новая JSON библиотека
"net/http"
"time"
)
 
type ProductData struct {
ID        string    [INLINE]json:"id"[/INLINE]
Name      string    [INLINE]json:"name"[/INLINE]
Price     float64   [INLINE]json:"price"[/INLINE]
Inventory int       [INLINE]json:"inventory"[/INLINE]
Updated   time.Time `json:"updated_at"`
}
 
func productHandler(w http.ResponseWriter, r *http.Request) {
// Получаем данные из хранилища
product := getProductFromStore(r.URL.Query().Get("id"))
 
// Устанавливаем заголовки
w.Header().Set("Content-Type", "application/json")
 
// Используем новый энкодер JSON
enc := json.NewEncoder(w)
// Настраиваем параметры сериализации
enc.SetIndent("", "")
enc.SetEscapeHTML(false)
 
if err := enc.Encode(product); err != nil {
    http.Error(w, "Error encoding response", http.StatusInternalServerError)
    return
}
}
 
func main() {
// Устанавливаем оптимальные таймауты
server := &http.Server{
    Addr:         ":8080",
    Handler:      setupRoutes(),
    ReadTimeout:  5 * time.Second,
    WriteTimeout: 10 * time.Second,
    IdleTimeout:  120 * time.Second,
}
 
// Запускаем сервер
if err := server.ListenAndServe(); err != nil {
    panic(err)
}
}

// stream_processor.go
package main
 
import (
"context"
"fmt"
"sync"
"time"
)
 
func processStreamItem(item interface{}) Result {
// Логика обработки...
return Result{}
}
 
func StreamProcessor(ctx context.Context, input <-chan interface{}) <-chan Result {
results := make(chan Result)
 
go func() {
    defer close(results)
    
    // Буферизуем результаты пакетами для снижения давления на GC
    batch := make([]Result, 0, 100)
    ticker := time.NewTicker(50 * time.Millisecond)
    defer ticker.Stop()
    
    for {
        select {
        case <-ctx.Done():
            // Отправляем оставшиеся результаты перед выходом
            for _, res := range batch {
                results <- res
            }
            return
            
        case item, ok := <-input:
            if !ok {
                // Канал закрыт, отправляем оставшиеся результаты
                for _, res := range batch {
                    results <- res
                }
                return
            }
            
            // Обрабатываем элемент
            result := processStreamItem(item)
            batch = append(batch, result)
            
            // Если накопили достаточно элементов, отправляем их
            if len(batch) >= 100 {
                for _, res := range batch {
                    results <- res
                }
                // Важно: переиспользуем существующий слайс
                batch = batch[:0]
            }
            
        case <-ticker.C:
            // Периодически отправляем накопленные результаты
            for _, res := range batch {
                results <- res
            }
            batch = batch[:0]
        }
    }
}()
 
return results
}

// Раньше это иногда работало без паники:
var conf *Config
// Метод не обращается к полям структуры
name := conf.GetName() 
 
// В Go 1.25 это ВСЕГДА вызовет панику

# Если ваш отладчик не поддерживает DWARF v5, можно временно отключить:
go build -ldflags "-dwarfVersion=4" myapp.go

// Это работает сейчас, но API может измениться в будущих версиях
type Person struct {
    Name string `json:"name" jsonv2:"fullName"`
}

// Код, который "случайно" работал, может начать вести себя иначе
// из-за изменений в планировании горутин
go func() { 
    time.Sleep(1 * time.Millisecond)
    ready = true 
}()
// Раньше этого времени "обычно хватало"
time.Sleep(5 * time.Millisecond) 
if ready {
    // ...
}

var wg sync.WaitGroup
wg.Add(1)
go func() { 
    defer wg.Done()
    // работа...
    ready = true 
}()
wg.Wait()

var errGroup errors.ErrorGroup
errGroup.Add(os.ErrNotExist)
errGroup.Add(os.ErrPermission)
 
// В Go 1.24 это вернуло бы false
// В Go 1.25 вернет true
if errors.Is(errGroup.Err(), os.ErrNotExist) {
    // ...
}

analytics-engine/
├── cmd/
│   └── server/
│       └── main.go      # Точка входа
├── internal/
│   ├── api/
│   │   ├── gateway.go   # API-шлюз
│   │   └── query.go     # API запросов
│   ├── validation/
│   │   └── service.go   # Сервис валидации
│   ├── processor/
│   │   └── service.go   # Процессор событий
│   ├── analytics/
│   │   └── engine.go    # Аналитический движок
│   └── storage/
│       └── repository.go # Хранилище данных
├── pkg/
│   ├── models/
│   │   └── event.go     # Модели данных
│   ├── errors/
│   │   └── errors.go    # Работа с ошибками
│   └── metrics/
│       └── metrics.go   # Метрики и мониторинг
├── go.mod
└── go.sum

// pkg/models/event.go
package models
 
import (
    "time"
)
 
// Event представляет событие пользовательского взаимодействия
type Event struct {
    ID            string            [INLINE]json:"id"[/INLINE]
    UserID        string            [INLINE]json:"user_id"[/INLINE]
    SessionID     string            [INLINE]json:"session_id"[/INLINE]
    Type          string            [INLINE]json:"type"[/INLINE]
    Timestamp     time.Time         [INLINE]json:"timestamp"[/INLINE]
    Properties    map[string]interface{} `json:"properties"`
    
    // Поля, добавляемые при обработке
    DeviceInfo    *DeviceInfo       `json:"device_info,omitempty"`
    GeoLocation   *GeoLocation      `json:"geo_location,omitempty"`
    Processed     bool              [INLINE]json:"processed"[/INLINE]
    ProcessedAt   time.Time         `json:"processed_at,omitempty"`
}
 
// DeviceInfo содержит информацию об устройстве пользователя
type DeviceInfo struct {
    Type        string `json:"type"`
    Browser     string `json:"browser,omitempty"`
    OS          string `json:"os,omitempty"`
    Resolution  string `json:"resolution,omitempty"`
}
 
// GeoLocation содержит географическую информацию
type GeoLocation struct {
    Country     string  `json:"country,omitempty"`
    City        string  `json:"city,omitempty"`
    Latitude    float64 `json:"latitude,omitempty"`
    Longitude   float64 `json:"longitude,omitempty"`
}

// internal/storage/repository.go
package storage
 
import (
    "context"
    "github.com/yourusername/analytics-engine/pkg/models"
)
 
// EventRepository определяет интерфейс для хранилища событий
type EventRepository interface {
    SaveEvent(ctx context.Context, event *models.Event) error
    GetEventByID(ctx context.Context, id string) (*models.Event, error)
    QueryEvents(ctx context.Context, filter EventFilter) ([]models.Event, error)
    SaveAnalytics(ctx context.Context, analysis *models.AnalyticsResult) error
    GetAnalytics(ctx context.Context, query AnalyticsQuery) ([]models.AnalyticsResult, error)
}
 
// EventFilter определяет параметры для фильтрации событий
type EventFilter struct {
    UserID    string
    SessionID string
    Type      string
    FromTime  time.Time
    ToTime    time.Time
    Limit     int
    Offset    int
}
 
// AnalyticsQuery определяет параметры для запроса аналитики
type AnalyticsQuery struct {
    Metric    string
    Dimension string
    FromTime  time.Time
    ToTime    time.Time
}

// internal/api/gateway.go
package api
 
import (
    "context"
    "encoding/json/v2" // Экспериментальный JSON пакет
    "net/http"
    "github.com/google/uuid"
    "github.com/yourusername/analytics-engine/internal/validation"
    "github.com/yourusername/analytics-engine/pkg/errors"
    "github.com/yourusername/analytics-engine/pkg/models"
)
 
// Gateway представляет API-шлюз для приема событий
type Gateway struct {
    validator   validation.Service
    eventCh     chan models.Event
    errorGroup  errors.ErrorGroup // Новая группировка ошибок
}
 
func NewGateway(validator validation.Service, bufferSize int) *Gateway {
    return &Gateway{
        validator: validator,
        eventCh:   make(chan models.Event, bufferSize),
    }
}
 
// Канал для получения событий
func (g *Gateway) EventChannel() <-chan models.Event {
    return g.eventCh
}
 
// Обработчик HTTP для приема событий
func (g *Gateway) HandleEvents(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    
    // Используем новый декодер JSON
    var events []models.Event
    decoder := json.NewDecoder(r.Body)
    if err := decoder.Decode(&events); err != nil {
        http.Error(w, "Invalid JSON payload", http.StatusBadRequest)
        return
    }
    
    // Валидируем и отправляем события на обработку
    var validEvents []models.Event
    
    for _, event := range events {
        // Если ID не указан, генерируем новый
        if event.ID == "" {
            event.ID = uuid.New().String()
        }
        
        // Валидируем событие
        if err := g.validator.ValidateEvent(ctx, &event); err != nil {
            g.errorGroup.Add(err) // Используем новую группировку ошибок
            continue
        }
        
        validEvents = append(validEvents, event)
        
        // Асинхронно отправляем событие на обработку
        select {
        case g.eventCh <- event:
            // Событие отправлено успешно
        default:
            // Канал заполнен, логируем ошибку
            g.errorGroup.Add(errors.New("event channel is full"))
        }
    }
    
    // Отправляем ответ клиенту
    w.Header().Set("Content-Type", "application/json")
    response := map[string]interface{}{
        "accepted": len(validEvents),
        "total":    len(events),
    }
    
    if err := json.NewEncoder(w).Encode(response); err != nil {
        http.Error(w, "Failed to encode response", http.StatusInternalServerError)
        return
    }
}

// internal/processor/service.go
package processor
 
import (
    "context"
    "time"
    "runtime"
    "sync"
    "github.com/yourusername/analytics-engine/internal/storage"
    "github.com/yourusername/analytics-engine/pkg/errors"
    "github.com/yourusername/analytics-engine/pkg/models"
)
 
// Service представляет процессор событий
type Service struct {
    repository      storage.EventRepository
    geoService      GeoService
    deviceDetector  DeviceDetector
    workerCount     int
    timeout         time.Duration
}
 
// NewService создает новый процессор событий
func NewService(repo storage.EventRepository, geo GeoService, device DeviceDetector) *Service {
    return &Service{
        repository:     repo,
        geoService:     geo,
        deviceDetector: device,
        workerCount:    runtime.GOMAXPROCS(0), // Используем все доступные ядра
        timeout:        5 * time.Second,
    }
}
 
// ProcessEvents обрабатывает поток событий
func (s *Service) ProcessEvents(ctx context.Context, eventCh <-chan models.Event) {
    var wg sync.WaitGroup
    
    // Запускаем пул обработчиков
    for i := 0; i < s.workerCount; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            
            for {
                select {
                case event, ok := <-eventCh:
                    if !ok {
                        return // Канал закрыт
                    }
                    
                    // Создаем контекст с таймаутом для обработки события
                    eventCtx, cancel := context.WithTimeout(ctx, s.timeout)
                    
                    // Обрабатываем событие
                    err := s.processEvent(eventCtx, &event)
                    cancel()
                    
                    if err != nil {
                        // Логируем ошибку
                        // ...
                    }
                    
                case <-ctx.Done():
                    return // Контекст отменен
                }
            }
        }()
    }
    
    // Ожидаем завершения работы всех горутин при отмене контекста
    go func() {
        <-ctx.Done()
        wg.Wait()
        // Логируем завершение работы
    }()
}
 
// processEvent обрабатывает одно событие
func (s *Service) processEvent(ctx context.Context, event *models.Event) error {
    var errorGroup errors.ErrorGroup // Используем новую группировку ошибок
    
    // Используем горутины для параллельной обработки
    var wg sync.WaitGroup
    
    // Определяем информацию об устройстве
    wg.Add(1)
    go func() {
        defer wg.Done()
        
        deviceCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
        defer cancel()
        
        deviceInfo, err := s.deviceDetector.DetectDevice(deviceCtx, event.Properties)
        if err != nil {
            errorGroup.Add(err)
            return
        }
        
        event.DeviceInfo = deviceInfo
    }()
    
    // Определяем геолокацию
    wg.Add(1)
    go func() {
        defer wg.Done()
        
        geoCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
        defer cancel()
        
        location, err := s.geoService.GetLocation(geoCtx, event.Properties)
        if err != nil {
            errorGroup.Add(err)
            return
        }
        
        event.GeoLocation = location
    }()
    
    // Ожидаем завершения всех операций
    wg.Wait()
    
    // Проверяем, были ли ошибки
    if err := errorGroup.Err(); err != nil {
        return err
    }
    
    // Обновляем статус события
    event.Processed = true
    event.ProcessedAt = time.Now()
    
    // Сохраняем обработанное событие
    return s.repository.SaveEvent(ctx, event)
}

// internal/analytics/engine.go
package analytics
 
import (
    "context"
    "sync"
    "time"
    "github.com/yourusername/analytics-engine/internal/storage"
    "github.com/yourusername/analytics-engine/pkg/errors"
    "github.com/yourusername/analytics-engine/pkg/models"
)
 
// Engine представляет аналитический движок
type Engine struct {
    repository     storage.EventRepository
    metricHandlers map[string]MetricHandler
    dimensions     map[string]DimensionExtractor
    batchSize      int
}
 
// MetricHandler вычисляет метрику для набора событий
type MetricHandler func([]models.Event) float64
 
// DimensionExtractor извлекает значение измерения из события
type DimensionExtractor func(models.Event) string
 
// NewEngine создает новый аналитический движок
func NewEngine(repo storage.EventRepository) *Engine {
    e := &Engine{
        repository:     repo,
        metricHandlers: make(map[string]MetricHandler),
        dimensions:     make(map[string]DimensionExtractor),
        batchSize:      1000, // Оптимальный размер пакета для GC
    }
    
    // Регистрируем стандартные метрики
    e.RegisterMetric("session_duration", calculateSessionDuration)
    e.RegisterMetric("events_per_session", calculateEventsPerSession)
    
    // Регистрируем стандартные измерения
    e.RegisterDimension("country", extractCountry)
    e.RegisterDimension("device_type", extractDeviceType)
    
    return e
}
 
// RegisterMetric регистрирует обработчик метрики
func (e *Engine) RegisterMetric(name string, handler MetricHandler) {
    e.metricHandlers[name] = handler
}
 
// RegisterDimension регистрирует экстрактор измерения
func (e *Engine) RegisterDimension(name string, extractor DimensionExtractor) {
    e.dimensions[name] = extractor
}
 
// CalculateAnalytics рассчитывает аналитику на основе запроса
func (e *Engine) CalculateAnalytics(ctx context.Context, query storage.AnalyticsQuery) ([]models.AnalyticsResult, error) {
    // Проверяем наличие метрики и измерения
    metricHandler, ok := e.metricHandlers[query.Metric]
    if !ok {
        return nil, errors.New("unknown metric: " + query.Metric)
    }
    
    dimensionExtractor, ok := e.dimensions[query.Dimension]
    if !ok {
        return nil, errors.New("unknown dimension: " + query.Dimension)
    }
    
    // Получаем все события за указанный период
    filter := storage.EventFilter{
        FromTime: query.FromTime,
        ToTime:   query.ToTime,
    }
    
    var results []models.AnalyticsResult
    var errorGroup errors.ErrorGroup // Используем новую группировку ошибок
    
    // Обрабатываем события пакетами для оптимизации потребления памяти
    offset := 0
    for {
        filter.Limit = e.batchSize
        filter.Offset = offset
        
        events, err := e.repository.QueryEvents(ctx, filter)
        if err != nil {
            return nil, err
        }
        
        if len(events) == 0 {
            break // Больше нет событий
        }
        
        // Группируем события по значению измерения
        dimensionGroups := make(map[string][]models.Event)
        for _, event := range events {
            dimValue := dimensionExtractor(event)
            dimensionGroups[dimValue] = append(dimensionGroups[dimValue], event)
        }
        
        // Вычисляем метрику для каждой группы
        var mu sync.Mutex
        var wg sync.WaitGroup
        
        for dimValue, dimEvents := range dimensionGroups {
            wg.Add(1)
            go func(value string, evts []models.Event) {
                defer wg.Done()
                
                // Вычисляем метрику
                metricValue := metricHandler(evts)
                
                // Создаем результат
                result := models.AnalyticsResult{
                    Metric:    query.Metric,
                    Dimension: query.Dimension,
                    Value:     value,
                    Count:     float64(len(evts)),
                    Result:    metricValue,
                    Timestamp: time.Now(),
                }
                
                // Сохраняем результат атомарно
                mu.Lock()
                results = append(results, result)
                mu.Unlock()
                
                // Сохраняем результат в хранилище
                if err := e.repository.SaveAnalytics(ctx, &result); err != nil {
                    errorGroup.Add(err)
                }
            }(dimValue, dimEvents)
        }
        
        wg.Wait()
        
        // Проверяем наличие ошибок
        if err := errorGroup.Err(); err != nil {
            return nil, err
        }
        
        offset += len(events)
        
        // Если получили меньше событий, чем размер пакета, значит это последний пакет
        if len(events) < e.batchSize {
            break
        }
    }
    
    return results, nil
}

// cmd/server/main.go
package main
 
import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "runtime"
    "syscall"
    "time"
    
    "github.com/yourusername/analytics-engine/internal/api"
    "github.com/yourusername/analytics-engine/internal/analytics"
    "github.com/yourusername/analytics-engine/internal/processor"
    "github.com/yourusername/analytics-engine/internal/storage"
    "github.com/yourusername/analytics-engine/internal/validation"
)
 
func main() {
    // Устанавливаем оптимальные настройки для GC
    runtime.GOMAXPROCS(runtime.NumCPU())
    
    // Создаем корневой контекст с отменой
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    
    // Настраиваем обработку сигналов для грациозного завершения
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    go func() {
        sig := <-sigChan
        log.Printf("Received signal %s, initiating graceful shutdown", sig)
        cancel()
    }()
    
    // Инициализируем компоненты
    repo := storage.NewRepository() // В реальном проекте здесь будет подключение к БД
    validator := validation.NewService()
    geoService := processor.NewGeoService()
    deviceDetector := processor.NewDeviceDetector()
    
    // Создаем и настраиваем API-шлюз
    gateway := api.NewGateway(validator, 10000) // Буфер на 10k событий
    
    // Создаем процессор событий
    proc := processor.NewService(repo, geoService, deviceDetector)
    
    // Создаем аналитический движок
    engine := analytics.NewEngine(repo)
    
    // Создаем API для запросов
    queryAPI := api.NewQueryAPI(repo, engine)
    
    // Запускаем обработку событий
    go proc.ProcessEvents(ctx, gateway.EventChannel())
    
    // Настраиваем и запускаем HTTP-сервер
    mux := http.NewServeMux()
    mux.HandleFunc("/api/v1/events", gateway.HandleEvents)
    mux.HandleFunc("/api/v1/query", queryAPI.HandleQuery)
    
    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  60 * time.Second,
    }
    
    // Запускаем сервер в отдельной горутине
    go func() {
        log.Println("Starting server on :8080")
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server error: %v", err)
        }
    }()
    
    // Ожидаем завершения контекста
    <-ctx.Done()
    
    // Грациозно завершаем HTTP-сервер
    shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer shutdownCancel()
    
    if err := server.Shutdown(shutdownCtx); err != nil {
        log.Printf("Server shutdown error: %v", err)
    }
    
    log.Println("Server gracefully stopped")
}

#!/bin/bash
[H2]build.sh[/H2]
 
# Этап 1: Сборка инструментированной версии
go build -pgo=off -o analytics-engine ./cmd/server
 
# Этап 2: Запуск инструментированной версии и сбор профиля
./analytics-engine -cpuprofile=profile.pprof &
PID=$!
 
# Генерация тестовой нагрузки
go run ./tools/load-generator -duration=60s -rps=1000
 
# Остановка сервера
kill $PID
 
# Этап 3: Сборка оптимизированной версии с использованием профиля
GOEXPERIMENT=jsonv2 go build -pgo=profile.pprof -o analytics-engine-optimized ./cmd/server
 
echo "Build complete. Optimized binary: analytics-engine-optimized"

// domain/user.go - Бизнес-модель
package domain
 
type User struct {
ID       string
Username string
Email    string
}
 
// Порт для репозитория пользователей
type UserRepository interface {
Save(user User) error
FindByID(id string) (User, error)
FindByUsername(username string) (User, error)
}
 
// Порт для сервиса отправки уведомлений
type NotificationService interface {
SendWelcomeEmail(user User) error
}
 
// domain/service.go - Бизнес-логика
package domain
 
import "errors"
 
type UserService struct {
repo       UserRepository
notifier   NotificationService
}
 
func NewUserService(repo UserRepository, notifier NotificationService) *UserService {
return &UserService{
    repo:     repo,
    notifier: notifier,
}
}
 
func (s *UserService) RegisterUser(username, email string) (User, error) {
// Группировка ошибок с использованием нового механизма
var errGroup errors.ErrorGroup
 
// Проверяем, существует ли пользователь с таким именем
existingUser, err := s.repo.FindByUsername(username)
if err == nil && existingUser.Username != "" {
    errGroup.Add(errors.New("пользователь с таким именем уже существует"))
}
 
// Проверяем валидность email
if !isValidEmail(email) {
    errGroup.Add(errors.New("некорректный email адрес"))
}
 
// Проверяем наличие ошибок
if err := errGroup.Err(); err != nil {
    return User{}, err
}
 
// Создаем нового пользователя
user := User{
    ID:       generateID(),
    Username: username,
    Email:    email,
}
 
// Сохраняем пользователя
if err := s.repo.Save(user); err != nil {
    return User{}, err
}
 
// Отправляем приветственное письмо
if err := s.notifier.SendWelcomeEmail(user); err != nil {
    // Мы не прерываем регистрацию из-за ошибки отправки письма,
    // но логируем ее для дальнейшего анализа
    logError(err)
}
 
return user, nil
}
 
// infrastructure/postgres/user_repository.go - Адаптер для PostgreSQL
package postgres
 
import (
"database/sql"
"github.com/yourusername/myapp/domain"
)
 
type UserRepository struct {
db *sql.DB
}
 
func NewUserRepository(db *sql.DB) *UserRepository {
return &UserRepository{db: db}
}
 
func (r *UserRepository) Save(user domain.User) error {
// Реализация сохранения пользователя в PostgreSQL
// ...
return nil
}
 
func (r *UserRepository) FindByID(id string) (domain.User, error) {
// Реализация поиска пользователя по ID
// ...
return domain.User{}, nil
}
 
// infrastructure/email/notification_service.go - Адаптер для почтовых уведомлений
package email
 
import "github.com/yourusername/myapp/domain"
 
type NotificationService struct {
smtpClient SMTPClient
}
 
func (s *NotificationService) SendWelcomeEmail(user domain.User) error {
// Реализация отправки приветственного письма
// ...
return nil
}

// entity/task.go - Бизнес-сущности (центральный слой)
package entity
 
type Task struct {
ID          string
Title       string
Description string
Completed   bool
}
 
// usecase/task.go - Слой бизнес-правил и сценариев использования
package usecase
 
import (
"context"
"github.com/yourusername/myapp/entity"
)
 
type TaskRepository interface {
Save(ctx context.Context, task entity.Task) error
FindByID(ctx context.Context, id string) (entity.Task, error)
FindAll(ctx context.Context) ([]entity.Task, error)
}
 
type TaskUseCase struct {
repo TaskRepository
}
 
func NewTaskUseCase(repo TaskRepository) *TaskUseCase {
return &TaskUseCase{repo: repo}
}
 
func (uc *TaskUseCase) CreateTask(ctx context.Context, title, description string) (entity.Task, error) {
task := entity.Task{
    ID:          generateID(),
    Title:       title,
    Description: description,
    Completed:   false,
}
 
if err := uc.repo.Save(ctx, task); err != nil {
    return entity.Task{}, err
}
 
return task, nil
}
 
// controller/task.go - Слой контроллеров (адаптеров для входящих запросов)
package controller
 
import (
"context"
"net/http"
"encoding/json/v2" // Используем новый пакет JSON
"github.com/yourusername/myapp/usecase"
)
 
type TaskController struct {
useCase *usecase.TaskUseCase
}
 
func NewTaskController(useCase *usecase.TaskUseCase) *TaskController {
return &TaskController{useCase: useCase}
}
 
func (c *TaskController) CreateTask(w http.ResponseWriter, r *http.Request) {
var input struct {
    Title       string `json:"title"`
    Description string `json:"description"`
}
 
decoder := json.NewDecoder(r.Body)
if err := decoder.Decode(&input); err != nil {
    http.Error(w, "Invalid input", http.StatusBadRequest)
    return
}
 
ctx := r.Context()
task, err := c.useCase.CreateTask(ctx, input.Title, input.Description)
if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
}
 
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(task)
}
 
// repository/postgres/task_repository.go - Слой инфраструктуры (адаптеры для хранения данных)
package postgres
 
import (
"context"
"database/sql"
"github.com/yourusername/myapp/entity"
)
 
type TaskRepository struct {
db *sql.DB
}
 
func NewTaskRepository(db *sql.DB) *TaskRepository {
return &TaskRepository{db: db}
}
 
func (r *TaskRepository) Save(ctx context.Context, task entity.Task) error {
// Реализация сохранения задачи в PostgreSQL
// ...
return nil
}

// command/create_product.go
package command
 
type CreateProductCommand struct {
ID          string
Name        string
Description string
Price       float64
}
 
type CommandHandler interface {
Handle(cmd interface{}) error
}
 
// event/product_created.go
package event
 
import "time"
 
type ProductCreatedEvent struct {
ID          string
Name        string
Description string
Price       float64
Timestamp   time.Time
}
 
type EventStore interface {
SaveEvents(aggregateID string, events []interface{}) error
GetEvents(aggregateID string) ([]interface{}, error)
}
 
// aggregate/product.go
package aggregate
 
import (
"github.com/yourusername/myapp/event"
"time"
)
 
type Product struct {
id          string
name        string
description string
price       float64
events      []interface{} // Накопленные события
}
 
func NewProduct() *Product {
return &Product{
    events: make([]interface{}, 0),
}
}
 
// Apply применяет команду и генерирует событие
func (p *Product) Create(id, name, description string, price float64) {
// Создаем событие
evt := event.ProductCreatedEvent{
    ID:          id,
    Name:        name,
    Description: description,
    Price:       price,
    Timestamp:   time.Now(),
}
 
// Применяем событие к агрегату
p.ApplyEvent(evt)
 
// Добавляем событие в список для сохранения
p.events = append(p.events, evt)
}
 
// ApplyEvent изменяет состояние агрегата на основе события
func (p *Product) ApplyEvent(evt interface{}) {
switch e := evt.(type) {
case event.ProductCreatedEvent:
    p.id = e.ID
    p.name = e.Name
    p.description = e.Description
    p.price = e.Price
}
}
 
// GetUncommittedEvents возвращает накопленные события
func (p *Product) GetUncommittedEvents() []interface{} {
return p.events
}
 
// ClearUncommittedEvents очищает список накопленных событий
func (p *Product) ClearUncommittedEvents() {
p.events = make([]interface{}, 0)
}
 
// handler/product_command_handler.go
package handler
 
import (
"github.com/yourusername/myapp/aggregate"
"github.com/yourusername/myapp/command"
"github.com/yourusername/myapp/event"
"errors"
)
 
type ProductCommandHandler struct {
eventStore event.EventStore
}
 
func NewProductCommandHandler(store event.EventStore) *ProductCommandHandler {
return &ProductCommandHandler{
    eventStore: store,
}
}
 
func (h *ProductCommandHandler) Handle(cmd interface{}) error {
switch c := cmd.(type) {
case command.CreateProductCommand:
    // Создаем новый агрегат
    product := aggregate.NewProduct()
    
    // Применяем команду к агрегату
    product.Create(c.ID, c.Name, c.Description, c.Price)
    
    // Сохраняем события
    return h.eventStore.SaveEvents(c.ID, product.GetUncommittedEvents())
    
default:
    return errors.New("unknown command type")
}
}
 
// infrastructure/eventstore/memory_event_store.go
package eventstore
 
import (
"sync"
)
 
type MemoryEventStore struct {
events map[string][]interface{}
mu     sync.RWMutex
}
 
func NewMemoryEventStore() *MemoryEventStore {
return &MemoryEventStore{
    events: make(map[string][]interface{}),
}
}
 
func (s *MemoryEventStore) SaveEvents(aggregateID string, newEvents []interface{}) error {
s.mu.Lock()
defer s.mu.Unlock()
 
existingEvents, ok := s.events[aggregateID]
if !ok {
    existingEvents = make([]interface{}, 0)
}
 
s.events[aggregateID] = append(existingEvents, newEvents...)
return nil
}
 
func (s *MemoryEventStore) GetEvents(aggregateID string) ([]interface{}, error) {
s.mu.RLock()
defer s.mu.RUnlock()
 
events, ok := s.events[aggregateID]
if !ok {
    return make([]interface{}, 0), nil
}
 
return events, nil
}

// core/pricing/calculator.go - Функциональное ядро
package pricing
 
import "math"
 
// Чистая функция без побочных эффектов
func CalculatePrice(basePrice, discount float64, quantity int, taxRate float64) float64 {
discountedPrice := basePrice * (1 - discount)
subtotal := discountedPrice * float64(quantity)
tax := subtotal * taxRate
return math.Round((subtotal + tax) * 100) / 100 // Округляем до двух знаков
}
 
// shell/order_service.go - Императивная оболочка
package shell
 
import (
"context"
"database/sql"
"github.com/yourusername/myapp/core/pricing"
"time"
)
 
type Order struct {
ID          string
CustomerID  string
ProductID   string
Quantity    int
BasePrice   float64
Discount    float64
TotalPrice  float64
CreatedAt   time.Time
}
 
type OrderService struct {
db *sql.DB
taxRateService TaxRateService
}
 
// Императивный метод с побочными эффектами
func (s *OrderService) CreateOrder(ctx context.Context, customerID, productID string, quantity int) (*Order, error) {
// Получаем базовую цену из базы данных
basePrice, err := s.getProductPrice(ctx, productID)
if err != nil {
    return nil, err
}
 
// Получаем скидку для клиента
discount, err := s.getCustomerDiscount(ctx, customerID)
if err != nil {
    return nil, err
}
 
// Получаем налоговую ставку
taxRate, err := s.taxRateService.GetTaxRate(ctx, customerID)
if err != nil {
    return nil, err
}
 
// Вычисляем итоговую цену с использованием чистой функции
totalPrice := pricing.CalculatePrice(basePrice, discount, quantity, taxRate)
 
// Создаем заказ
order := &Order{
    ID:         generateOrderID(),
    CustomerID: customerID,
    ProductID:  productID,
    Quantity:   quantity,
    BasePrice:  basePrice,
    Discount:   discount,
    TotalPrice: totalPrice,
    CreatedAt:  time.Now(),
}
 
// Сохраняем заказ в базу данных
if err := s.saveOrder(ctx, order); err != nil {
    return nil, err
}
 
return order, nil
}

func validateUser(user User) error {
var errGroup errors.ErrorGroup
 
// Валидируем разные аспекты пользователя параллельно
var wg sync.WaitGroup
 
wg.Add(1)
go func() {
    defer wg.Done()
    if err := validateEmail(user.Email); err != nil {
        errGroup.Add(fmt.Errorf("некорректный email: %w", err))
    }
}()
 
wg.Add(1)
go func() {
    defer wg.Done()
    if err := validatePassword(user.Password); err != nil {
        errGroup.Add(fmt.Errorf("некорректный пароль: %w", err))
    }
}()
 
wg.Add(1)
go func() {
    defer wg.Done()
    if err := checkUsernameAvailable(user.Username); err != nil {
        errGroup.Add(fmt.Errorf("проблема с именем пользователя: %w", err))
    }
}()
 
wg.Wait()
return errGroup.Err()
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
// Создаем контекст с таймаутом
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel()
 
// Добавляем важную информацию в контекст
ctx = context.WithValue(ctx, "requestID", generateRequestID())
ctx = context.WithValue(ctx, "userIP", getClientIP(r))
 
// Выполняем операцию с учетом контекста
result, err := processWithContext(ctx, r.URL.Query().Get("query"))
if err != nil {
    handleError(w, err)
    return
}
 
// Отправляем результат
json.NewEncoder(w).Encode(result)
}

// Пул для переиспользования буферов
var bufferPool = sync.Pool{
New: func() interface{} {
    return make([]byte, 0, 64*1024) // 64KB буферы
},
}
 
func processRequest(data []byte) []byte {
// Получаем буфер из пула
buffer := bufferPool.Get().([]byte)
buffer = buffer[:0] // Сбрасываем длину, но сохраняем емкость
 
// Используем буфер
// ...
 
// Возвращаем буфер в пул
bufferPool.Put(buffer)
 
// Возвращаем результат
return result
}

func TestConcurrentProcessor(t *testing.T) {
// Создаем изолированную среду для тестирования
bubble := synctest.NewBubble(t)
defer bubble.Close()
 
// Получаем фейковые часы
clock := bubble.Clock()
 
processor := NewProcessor()
results := make(chan Result, 100)
 
// Запускаем обработку
go processor.ProcessBatch(clock, results)
 
// Перемещаем время вперед
clock.Advance(500 * time.Millisecond)
 
// Проверяем результаты
select {
case result := <-results:
    // Проверяем результаты
default:
    t.Error("Результаты не получены")
}
}

func handleGetUser(w http.ResponseWriter, r *http.Request) {
// Получаем ID пользователя
userID := r.URL.Query().Get("id")
if userID == "" {
    http.Error(w, "Missing user ID", http.StatusBadRequest)
    return
}
 
// Получаем пользователя
user, err := userService.GetUser(r.Context(), userID)
if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
}
 
// Используем новый JSON энкодер
w.Header().Set("Content-Type", "application/json")
encoder := json.NewEncoder(w)
encoder.SetEscapeHTML(false) // Для оптимизации производительности
if err := encoder.Encode(user); err != nil {
    http.Error(w, "Failed to encode response", http.StatusInternalServerError)
}
}

// Версионирование через HTTP-заголовки
func apiHandler(w http.ResponseWriter, r *http.Request) {
version := r.Header.Get("API-Version")
if version == "" {
    version = "1" // По умолчанию используем версию 1
}
 
switch version {
case "1":
    handleV1(w, r)
case "2":
    handleV2(w, r)
default:
    http.Error(w, "Unsupported API version", http.StatusBadRequest)
}
}

type CircuitBreaker struct {
threshold   int
failureCount int
halfOpenTime time.Duration
lastFailure  time.Time
state        string
mu           sync.Mutex
}
 
func (cb *CircuitBreaker) Execute(operation func() error) error {
cb.mu.Lock()
state := cb.state
cb.mu.Unlock()
 
if state == "open" {
    // Проверяем, можно ли перейти в полуоткрытое состояние
    if time.Since(cb.lastFailure) > cb.halfOpenTime {
        cb.mu.Lock()
        cb.state = "half-open"
        cb.mu.Unlock()
    } else {
        return errors.New("circuit breaker is open")
    }
}
 
// Выполняем операцию
err := operation()
 
cb.mu.Lock()
defer cb.mu.Unlock()
 
if err != nil {
    // Увеличиваем счетчик ошибок
    cb.failureCount++
    cb.lastFailure = time.Now()
    
    // Проверяем, нужно ли открыть circuit breaker
    if cb.failureCount >= cb.threshold || cb.state == "half-open" {
        cb.state = "open"
    }
    return err
} else if cb.state == "half-open" {
    // Успешная операция в полуоткрытом состоянии - возвращаемся к закрытому
    cb.state = "closed"
    cb.failureCount = 0
} else {
    // Успешная операция - сбрасываем счетчик ошибок
    cb.failureCount = 0
}
 
return nil
}