Go Backend Development for Microservices

Core Principles

• Apply Clean Architecture with clear separation into handlers, services, repositories, and domain models
• Prioritize interface-driven development with explicit dependency injection
• Write short, focused functions with a single responsibility
• Ensure safe use of goroutines, and guard shared state with channels or sync primitives

Project Structure

project/
├── cmd/           # Application entry points
├── internal/      # Private application code
├── pkg/           # Public library code
├── api/           # API definitions (OpenAPI, protobuf)
├── configs/       # Configuration files
└── test/          # Additional test utilities

Error Handling

• Always check and handle errors explicitly
• Use wrapped errors for traceability:

  fmt.Errorf("context: %w", err)

• Create custom error types for domain-specific errors
• Return errors up the call stack with appropriate context
• Log errors at the appropriate level with sufficient context

Context Propagation

• Use context propagation for request-scoped values, deadlines, and cancellations
• Pass context as the first parameter to functions
• Respect context cancellation in long-running operations
• Set appropriate timeouts for external calls

Observability

Distributed Tracing

• Add spans for significant operations
• Propagate trace context across service boundaries
• Include relevant attributes in spans

Metrics

• Implement custom metrics for business operations
• Use standard metric types (counters, gauges, histograms)
• Export metrics in Prometheus format

Structured Logging

• Use structured logging with consistent field names
• Include trace IDs in log entries
• Log at appropriate levels (debug, info, warn, error)

Security

• Apply input validation rigorously on all external inputs
• Use secure defaults for JWT tokens and cookies
• Implement proper authentication and authorization
• Sanitize data before logging to avoid leaking sensitive information
• Use prepared statements for database queries

Testing

Unit Tests

• Write table-driven unit tests with adequate coverage
• Use parallel test execution where safe
• Mock external dependencies using interfaces
• Focus on testing business logic

Integration Tests

• Separate integration tests from unit tests
• Use test containers for database and service dependencies
• Test actual API endpoints and responses

Concurrency

• Use goroutines appropriately for concurrent operations
• Guard shared state with channels or sync primitives
• Implement proper graceful shutdown
• Use worker pools for bounded concurrency

Documentation

• Document with GoDoc-style comments
• Keep comments up to date with code changes
• Document public APIs thoroughly
• Include examples in documentation where helpful

CI/CD Integration

• Maintain CI integration for linting and testing
• Use golangci-lint for comprehensive linting
• Run tests on every pull request
• Include code coverage reporting