The Gin framework uses a global mode setting (gin.SetMode()) which is not
thread-safe when tests run in parallel. Removing t.Parallel() from all
server tests that use gin.SetMode() prevents data races when running
tests with the race detector enabled.
All tests now pass with 'make test' which includes -race flag.
Story 1.2: Database Layer
- Test database client creation, connection, ping, and close
- Test connection pooling configuration
- Tests skip if database is not available (short mode)
Story 1.3: Health Monitoring and Metrics
- Test health registry registration and checking
- Test database health checker
- Test liveness and readiness checks
- Test metrics creation, middleware, and handler
- Test Prometheus metrics endpoint
Story 1.4: Error Handling and Error Bus
- Test channel-based error bus creation
- Test error publishing with context
- Test nil error handling
- Test channel full scenario
- Test graceful shutdown
- Fix Close() method to handle multiple calls safely
Story 1.5: HTTP Server and Middleware
- Test server creation with all middleware
- Test request ID middleware
- Test logging middleware
- Test panic recovery middleware
- Test CORS middleware
- Test timeout middleware
- Test health and metrics endpoints
- Test server shutdown
Story 1.6: OpenTelemetry Tracing
- Test tracer initialization (enabled/disabled)
- Test development and production modes
- Test OTLP exporter configuration
- Test graceful shutdown
- Test no-op tracer provider
All tests follow Go testing best practices:
- Table-driven tests where appropriate
- Parallel execution
- Proper mocking of interfaces
- Skip tests requiring external dependencies in short mode
- Remove emoji numbers from section headers (1-13)
- Remove rocket emoji from final congratulations message
- All sections now use plain numbers instead of emoji numbers
- Fix error return value checks (errcheck)
- Fix unused parameters by using underscore prefix
- Add missing package comments to all packages
- Fix context key type issue in middleware (use typed contextKey)
- Replace deprecated trace.NewNoopTracerProvider with noop.NewTracerProvider
- Fix embedded field selector in database client
- Remove trailing whitespace
- Remove revive linter (as requested) to avoid stuttering warnings for public API interfaces
All linting and formatting checks now pass.
- Verified all acceptance criteria for Stories 1.1-1.6
- Updated Status fields from Pending to Completed
- Marked all acceptance criteria checkboxes as completed
- All stories in Epic 1 are now fully implemented and verified
- Add fx.Invoke in main.go to force database and HTTP server creation
- This ensures all providers execute and their lifecycle hooks are registered
- Clean up debug logging statements
- Database migrations and HTTP server now start correctly on application startup
Fixes issue where database migrations and HTTP server were not starting
because FX providers were not being executed (lazy evaluation).
- Added logging when HTTP server OnStart hook is called
- Added error logging for database migration failures
- This will help identify if hooks are being called and where failures occur
- Added better error detection for HTTP server startup
- Added connectivity check to verify server is actually listening
- Increased wait time to 500ms for better error detection
- Added warning log if server connectivity check fails (may still be starting)
- Improved logging messages for server startup
This should help diagnose why the HTTP server isn't starting and provide better visibility into the startup process.
Fixes:
- Added database connection logging with masked DSN
- Added migration progress logging
- Added HTTP server startup logging with address
- Fixed database provider to accept logger parameter
- Improved error visibility throughout initialization
Documentation:
- Moved Story 1.7 (Service Client Interfaces) to Epic 2 as Story 2.7
- Updated Epic 1 and Epic 2 READMEs
- Updated COMPLETE_TASK_LIST.md
- Updated story metadata (ID, Epic, Dependencies)
These changes will help diagnose startup issues and provide better visibility into what the application is doing.
Story 1.6: OpenTelemetry Distributed Tracing
- Implemented tracer initialization with stdout (dev) and OTLP (prod) exporters
- Added HTTP request instrumentation via Gin middleware
- Integrated trace ID correlation in structured logs
- Added tracing configuration to config files
- Registered tracer provider in DI container
Documentation and Setup:
- Created Docker Compose setup for PostgreSQL database
- Added comprehensive Epic 1 summary with verification instructions
- Added Epic 0 summary with verification instructions
- Linked summaries in documentation index and epic READMEs
- Included detailed database testing instructions
- Added Docker Compose commands and troubleshooting guide
All Epic 1 stories (1.1-1.6) are now complete. Story 1.7 depends on Epic 2.
Implemented Epic 1 core kernel and infrastructure stories:
Story 1.1: Enhanced DI Container
- Added providers for database, health, metrics, and error bus
- Extended CoreModule to include all core services
Story 1.2: Database Layer with Ent ORM
- Created Ent schema for User, Role, Permission, AuditLog entities
- Implemented many-to-many relationships (User-Role, Role-Permission)
- Created database client wrapper with connection pooling
- Added database provider to DI container with migration support
Story 1.3: Health Monitoring and Metrics System
- Implemented health check registry and interface
- Added database health checker
- Created Prometheus metrics system with HTTP instrumentation
- Added health and metrics providers to DI container
Story 1.4: Error Handling and Error Bus
- Implemented channel-based error bus
- Created ErrorPublisher interface
- Added error bus provider with lifecycle management
Story 1.5: HTTP Server Foundation
- Created HTTP server with Gin framework
- Implemented comprehensive middleware stack:
- Request ID generation
- Structured logging
- Panic recovery with error bus integration
- Prometheus metrics collection
- CORS support
- Registered core routes: /healthz, /ready, /metrics
- Integrated with FX lifecycle for graceful shutdown
All components are integrated via DI container and ready for use.
Create ADR documenting the decision to use a monorepo structure with
service directories for organizing microservices (Option 1).
The ADR covers:
- Decision to use monorepo with service directories
- Rationale for monorepo vs separate repositories
- Proposed directory structure with cmd/ and services/
- Implementation strategy across epics
- Consequences and mitigations
- Migration path if needed in the future
This clarifies how services (Auth, Identity, Authz, Audit) should be
organized in the codebase while maintaining service independence and
microservices architecture principles.
Update status of all epic0 stories (0.1-0.5) from Pending to Completed:
- 0.1: Project Initialization - Directory structure and Go module setup
- 0.2: Configuration Management System - Viper-based config implemented
- 0.3: Structured Logging System - Zap logger with middleware implemented
- 0.4: CI/CD Pipeline - GitHub Actions workflow with tests and linting
- 0.5: DI and Bootstrap - FX-based DI container with lifecycle management
All stories have been implemented with tests and are working.
Install v2.1.6 manually in CI (not via action) to avoid --out-format flag
compatibility issues. This ensures both local and CI use the same version
and support version: 2 config format.
The golangci-lint-action has compatibility issues with v2.1.6 (uses
--out-format flag which v2 doesn't support). Install golangci-lint manually
to avoid action limitations and remove version field from config to be
compatible with CI v1.64.8. Local v2.x will work but may show warnings.
The golangci-lint-action doesn't properly support v2.1.6 (uses --out-format
flag which v2 doesn't support). Remove version: 2 from config to make it
compatible with CI v1.64.8. Local v2.x will still work but may show a
deprecation warning about the config format.
v3 action uses --out-format flag which v2.1.6 doesn't support.
Upgrade to v4 action which should properly support golangci-lint v2.
This should resolve the 'unknown flag: --out-format' error.
'latest' resolves to v1.64.8 which doesn't support version: 2 config.
Pin to v2.1.6 to match local development environment and ensure
v2 config compatibility.
v1.65.0 doesn't exist. Use 'latest' to automatically get a version
that supports v2 config format (version: 2). This should work with
both local v2.1.6 and CI.
v1.64.8 doesn't support version: 2 in config files.
Upgrade to v1.65.0 which supports v2 config format.
This ensures compatibility with local v2.1.6 and CI.
- Add version: 2 to .golangci.yml for local golangci-lint v2.1.6 compatibility
- Pin CI to use golangci-lint v1.64.8 explicitly (should support v2 config)
This ensures the config works both locally (v2.1.6) and in CI (v1.64.8).
If v1.64.8 doesn't support v2 config, we may need to upgrade CI to v2.
- Add comments to all noOpLogger methods to satisfy revive exported rule
- Remove deprecated output.format option (use default format instead)
This fixes the linting issues:
- exported: exported method noOpLogger.* should have comment or be unexported
- warning about deprecated output.format option
The CI uses golangci-lint v1.64.8 which doesn't support:
- version: 2 field (v2-only feature)
- formatters section (v2-only feature)
Removed version field and formatters section to make config compatible with v1.
Formatting will be checked by gofmt/goimports separately if needed.
Downgrade golangci-lint-action from v4 to v3 to match other actions
that were downgraded for Gitea compatibility (upload-artifact, codecov).
v4 actions are not fully supported on Gitea/GHES.
The golangci-lint-action tries to use tar with --posix option for caching,
but BusyBox tar (used in Alpine-based runners) doesn't support this option.
Skipping the cache avoids this compatibility issue.
- Remove t.Parallel() from tests that use gin.SetMode()
- gin.SetMode() modifies global state and is not thread-safe
- Tests affected:
* TestRequestIDMiddleware_GenerateNewID
* TestRequestIDMiddleware_UseExistingID
* TestLoggingMiddleware
* TestLoggingMiddleware_WithRequestID
* TestRequestIDMiddleware_MultipleRequests
- Add comments explaining why these tests cannot run in parallel
- All tests now pass with race detector enabled (-race flag)
This fixes data race warnings that were occurring when running tests
with the race detector, specifically when multiple tests tried to set
Gin's mode concurrently.
- Improve test file detection with more robust find command
- Use explicit variable assignment instead of pipe to grep
- Add debug output to show found test files
- Handle errors gracefully with 2>/dev/null || true
- Downgrade actions for Gitea compatibility
- upload-artifact@v4 -> v3 (Gitea doesn't support v4+)
- codecov-action@v4 -> v3 (preventive downgrade)
- Add Alpine Linux build dependencies installation step
- Install build-base and musl-dev when running on Alpine
- Required for CGO-enabled builds and race detector
- Disable CGO for verify build step when no tests exist
- Avoids requiring C build tools for simple compilation check
- Add tests for internal/config package (90.9% coverage)
- Test all viperConfig getter methods
- Test LoadConfig with default and environment-specific configs
- Test error handling for missing config files
- Add tests for internal/di package (88.1% coverage)
- Test Container lifecycle (NewContainer, Start, Stop)
- Test providers (ProvideConfig, ProvideLogger, CoreModule)
- Test lifecycle hooks registration
- Include mock implementations for testing
- Add tests for internal/logger package (96.5% coverage)
- Test zapLogger with JSON and console formats
- Test all logging levels and methods
- Test middleware (RequestIDMiddleware, LoggingMiddleware)
- Test context helper functions
- Include benchmark tests
- Update CI workflow to skip tests when no test files exist
- Add conditional test execution based on test file presence
- Add timeout for test execution
- Verify build when no tests are present
All tests follow Go best practices with table-driven patterns,
parallel execution where safe, and comprehensive coverage.
Implemented all 5 stories from Epic 0:
Story 0.1: Project Initialization
- Initialize Go module with path git.dcentral.systems/toolz/goplt
- Create complete directory structure (cmd/, internal/, pkg/, modules/, config/, etc.)
- Add comprehensive .gitignore for Go projects
- Create README.md with project overview and setup instructions
Story 0.2: Configuration Management System
- Define ConfigProvider interface in pkg/config
- Implement Viper-based configuration in internal/config
- Create configuration loader with environment support
- Add default, development, and production YAML config files
Story 0.3: Structured Logging System
- Define Logger interface in pkg/logger
- Implement Zap-based logger in internal/logger
- Add request ID middleware for Gin
- Create global logger export with convenience functions
- Support context-aware logging with request/user ID extraction
Story 0.4: CI/CD Pipeline
- Create GitHub Actions workflow for CI (test, lint, build, fmt)
- Add comprehensive Makefile with development commands
- Configure golangci-lint with reasonable defaults
Story 0.5: Dependency Injection and Bootstrap
- Create FX-based DI container in internal/di
- Implement provider functions for Config and Logger
- Create application entry point in cmd/platform/main.go
- Add lifecycle management with graceful shutdown
All acceptance criteria met:
- go build ./cmd/platform succeeds
- go test ./... runs successfully
- go mod verify passes
- Config loads from config/default.yaml
- Logger can be injected and used
- Application starts and shuts down gracefully
- Add comprehensive 8-phase implementation plan (docs/plan.md)
- Add 28 Architecture Decision Records (docs/adr/) covering all phases
- Add task tracking system with 283+ task files (docs/stories/)
- Add task generator script for automated task file creation
- Add reference playbooks and requirements documentation
This commit establishes the complete planning foundation for the Go
Platform implementation, documenting all architectural decisions and
providing detailed task breakdown for Phases 0-8.
