┌─ STREAM-FRAMEWORK Go 1.25+ · Production Ready

The Go framework,
agentic-first.

Stream Framework is a production-ready Go service template combining Fiber's speed, OpenTelemetry tracing, Sentry error monitoring, and a clean module-based architecture.

Get Started → View Architecture
✓MIT License ✓gRPC + REST ✓OpenTelemetry ✓Code Generator
bash — stream-framework REC 

						


						
						

							

								
REQ/S

								
—

							

							

								
P99 LATENCY

								
—

							

							

								
GOROUTINES

								
—

							

						

					

				

			

		


		
		

			

				

					FIBER·
					GORM·
					OPENTELEMETRY·
					SENTRY·
					gRPC·
					POSTGRESQL·
					REDIS·
					RABBITMQ·
					ZAP·
					JWT·
					SWAGGER·
					MONGODB·
				

			

		


		
		

			

				

					

						SYS:MODULES
					

					

						Everything you need to ship
					

					

						A complete service foundation so your team can focus on business logic,
						not boilerplate.
					

				


				

					

						

							
⚡

							[MOD-01]
						

						

							Fiber HTTP Server
						

						

							Built on FastHTTP — one of the fastest HTTP engines in Go. Express-style
							routing with composable middleware.
						

					

					

						

							
📡

							[MOD-02]
						

						

							gRPC + REST
						

						

							Run REST and gRPC servers simultaneously. Protobuf definitions with
							auto-generated Go stubs included.
						

					

					

						

							
🔭

							[MOD-03]
						

						

							OpenTelemetry Tracing
						

						

							Distributed tracing out of the box. Send spans to Jaeger, Tempo, or any
							OTLP endpoint.
						

					

					

						

							
🐛

							[MOD-04]
						

						

							Sentry Error Tracking
						

						

							First-class Sentry integration for exception tracking and performance
							monitoring in production.
						

					

					

						

							
⚙️

							[MOD-05]
						

						

							Queue System
						

						

							Pluggable queue drivers — PostgreSQL (SKIP LOCKED) or RabbitMQ. Includes
							a worker binary and failed-job CLI.
						

					

					

						

							
🔧

							[MOD-06]
						

						

							Code Generator
						

						

							Scaffold a full CRUD module — controller, service, repository, routes,
							DTOs, resources — with a single command.
						

					

					

						

							
🗄️

							[MOD-07]
						

						

							GORM + PostgreSQL
						

						

							GORM with auto table prefix, BaseModel and BaseAuditorModel,
							golang-migrate for schema versioning.
						

					

					

						

							
🔐

							[MOD-08]
						

						

							JWT + Session Auth
						

						

							JWT authentication with Redis-backed session management, role/permission
							authorization, and single-device mode.
						

					

					

						

							
📋

							[MOD-09]
						

						

							Structured Logging
						

						

							Zap-based structured logger with Graylog, S3, GCP, and file output
							targets, configurable via LOG_MODE.
						

					

				

			

		


		
		

			

				

					
					

						

							MODULE PATTERN
						

						

							Clean, expressive architecture
						

						

							Every feature lives in its own module following a strict
								Module → Controller → Service → Repository
								pattern. Generate a complete CRUD module with one command and focus on
								your business logic.
						


						

							

								── gen ── CRUD SCAFFOLD ──
							

							
./gen module product

# Creates:
# src/modules/product_module/
#   product_module.go
#   product_controller.go
#   product_service.go
#   product_repository.go
#   product_route.go
#   product_error.go
#   dtos/dtos.go
#   resource/product_resource.go
#   responses/

						


						
    
							
  • 
								→
								Register the module's routes in
									src/routes/http.go
							
    • 
							
  • 
								→
								Implement business logic in the service layer — no direct DB calls in
									controllers
							
    • 
							
  • 
								→
								Inject fake repositories via
									WithXxxRepositoryFactory
									for unit testing
							
    • 
						

					


					
					

						

							

								── product_route.go
								GO ──
							

							
package product_module

import (
    "github.com/gofiber/fiber/v2"
    "innovationstream.app/stream-framework/src/middlewares"
)

func (m module) Routes(
    route fiber.Router,
    mw *middlewares.Middleware,
) {
    c := m.Controller()
    products := route.Group("products")

    // Public routes
    products.Get("/", c.GetProducts)
    products.Get("/:id", c.GetProduct)

    // Protected routes
    products.Use(mw.JwtAuthProtected())
    products.Post("/", c.CreateProduct)
    products.Put("/:id", c.UpdateProduct)
    products.Delete("/:id", c.DeleteProduct)
}

						


						

							

								── product_controller.go
								GO ──
							

							
func (c Controller) GetProduct(f *fiber.Ctx) error {
    ctx, span := c.m.tracer.TraceStart(
        f.Context(), "GetProductController",
    )
    defer c.m.tracer.TraceEnd(span)

    id := f.Params("id")
    result, err := c.service().GetProductByID(ctx, id)
    if err != nil {
        return exception.HttpErrorResponseMapping(
            f, fiber.StatusNotFound,
            ProductNotFoundError, err,
        )
    }
    return f.JSON(fiber.Map{"data": result})
}

						

					

				

			

		


		
		

			

				

					

						REALTIME · 1HZ
					

					

						Observe everything, live
					

					

						A built-in monitor dashboard ships with every service — live CPU, memory,
						connection and load metrics, a request inspector with a Jaeger-style trace
						timeline, and a live log stream, straight from your browser.
					

				


				
				

					

						

							

							

							

						

						

							localhost:8000/monitor
						

						
					


					

						
						

						
						

							

								

									
CPU

									

										—%
									

									
								

								

									
MEM

									

										—MB
									

									
								

								

									
GOROUTINES

									

										—
									

									
								

								

									
REQ/S

									

										—
									

									
								

							


							
							

								
── ACCESS LOG ──

								

							

						

					

				

			

		


		
		

			

				

					

						BOOT SEQUENCE
					

					

						Up and running in minutes
					

					

						Four steps to get your first Stream service running locally.
					

				


				

					

						

							01
						

						

							

								Clone and install dependencies
							

							

								
# Install the CLI once (private module — set GOPRIVATE)
export GOPRIVATE=innovationstream.app/*
go install innovationstream.app/stream-framework/cmd/stream-go@latest

# Make sure go-installed binaries are on PATH, otherwise the shell
# reports "command not found: stream-go". Add this to ~/.zshrc or ~/.bashrc:
export PATH="$PATH:$(go env GOPATH)/bin"

# Scaffold a new project with the interactive wizard
stream-go create myapp
cd myapp

# — or clone manually —
# git clone https://gitlab.innovationstream.app/stream/stream-framework.git myapp && cd myapp && go mod tidy

							

						

					


					

						

							02
						

						

							

								Configure your environment
							

							

								
cp .env.example .env.dev
# Edit .env.dev — set DB_HOST, DB_NAME, REDIS_HOST, etc.
# ENV=local or development → loads .env.dev automatically

							

						

					


					

						

							03
						

						

							

								Run database migrations
							

							

								
migrate -path database/migrations \
        -database "$DATABASE_URL" up

							

						

					


					

						

							04
						

						

							

								Start the development server
							

							

								
air          # with live reload (recommended)
# or
go run .     # without live reload

# [App] HTTP service is running at port 8000

							

						

					

				


				

					Read the full documentation →