Configuration

Fuego uses sensible defaults out of the box, but provides extensive configuration options through fuego.yaml, environment variables, and programmatic options.

Configuration Priority

Configuration values are resolved in this order (highest to lowest priority):

Programmatic options - fuego.New(WithPort("8080"))
Environment variables - FUEGO_PORT=8080
fuego.yaml file - port: 8080
Default values - 3000

fuego.yaml Reference

Create fuego.yaml in your project root:

# Server configuration
port: 3000
host: 0.0.0.0

# Directory configuration
app_dir: app
static_dir: static
static_path: /static

# Development configuration
dev:
  hot_reload: true
  watch_extensions:
    - .go
    - .templ
  exclude_dirs:
    - node_modules
    - .git
    - _*

# Middleware configuration
middleware:
  logger: true
  recover: true

Configuration Options

Server Configuration

port

The port the server listens on.

Property	Value
Type	`string`
Default	`"3000"`
Env	`FUEGO_PORT`

port: "8080"

host

The host address to bind to.

Property	Value
Type	`string`
Default	`"0.0.0.0"`
Env	`FUEGO_HOST`

host: "127.0.0.1"  # localhost only
host: "0.0.0.0"    # all interfaces

Directory Configuration

app_dir

The directory containing your route files.

Property	Value
Type	`string`
Default	`"app"`
Env	`FUEGO_APP_DIR`

app_dir: src/routes

static_dir

The directory containing static files to serve.

Property	Value
Type	`string`
Default	`"static"`
Env	`FUEGO_STATIC_DIR`

static_dir: public/assets

static_path

The URL path prefix for static files.

Property	Value
Type	`string`
Default	`"/static"`
Env	`FUEGO_STATIC_PATH`

static_path: /assets

This means files in static/css/style.css would be served at /assets/css/style.css.

Development Configuration

dev.hot_reload

Enable hot reloading during development.

Property	Value
Type	`bool`
Default	`true`
Env	`FUEGO_HOT_RELOAD`

dev:
  hot_reload: true

dev.watch_extensions

File extensions to watch for changes.

Property	Value
Type	`[]string`
Default	`[".go", ".templ"]`

dev:
  watch_extensions:
    - .go
    - .templ
    - .html
    - .css

dev.exclude_dirs

Directories to exclude from file watching.

Property	Value
Type	`[]string`
Default	`["node_modules", ".git", "_*"]`

dev:
  exclude_dirs:
    - node_modules
    - .git
    - vendor
    - _build

Middleware Configuration

middleware.logger

Enable the built-in request logger.

Property	Value
Type	`bool`
Default	`true`
Env	`FUEGO_LOGGER`

middleware:
  logger: true

middleware.recover

Enable panic recovery middleware.

Property	Value
Type	`bool`
Default	`true`
Env	`FUEGO_RECOVER`

middleware:
  recover: true

Environment Variables

All configuration options can be set via environment variables with the FUEGO_ prefix:

Variable	Description	Default
`FUEGO_PORT`	Server port	`3000`
`FUEGO_HOST`	Server host	`0.0.0.0`
`FUEGO_APP_DIR`	App directory	`app`
`FUEGO_STATIC_DIR`	Static files directory	`static`
`FUEGO_STATIC_PATH`	Static URL path	`/static`
`FUEGO_HOT_RELOAD`	Enable hot reload	`true`
`FUEGO_LOGGER`	Enable request logger	`true`
`FUEGO_RECOVER`	Enable panic recovery	`true`
`FUEGO_LOG_LEVEL`	Log level	`info`
`FUEGO_DEV`	Development mode	`false`
`GO_ENV`	Environment (affects logging)	-

Log Level Configuration

Control logging verbosity with FUEGO_LOG_LEVEL:

# Log everything
export FUEGO_LOG_LEVEL=debug

# Log all requests (default)
export FUEGO_LOG_LEVEL=info

# Log only 4xx and 5xx
export FUEGO_LOG_LEVEL=warn

# Log only 5xx errors
export FUEGO_LOG_LEVEL=error

# Disable logging
export FUEGO_LOG_LEVEL=off

Setting FUEGO_DEV=true automatically sets log level to debug. Setting GO_ENV=production automatically sets log level to warn.

Programmatic Configuration

Configure your app in code using option functions:

package main

import "github.com/abdul-hamid-achik/fuego/pkg/fuego"

func main() {
    app := fuego.New(
        fuego.WithPort("8080"),
        fuego.WithHost("127.0.0.1"),
        fuego.WithAppDir("src/routes"),
        fuego.WithStaticDir("public"),
        fuego.WithStaticPath("/assets"),
    )
    
    app.Start()
}

Available Options

// Server options
fuego.WithPort("8080")           // Set server port
fuego.WithHost("127.0.0.1")      // Set server host

// Directory options
fuego.WithAppDir("src/routes")   // Set app directory
fuego.WithStaticDir("public")    // Set static files directory
fuego.WithStaticPath("/assets")  // Set static URL path

// Load from config file
fuego.WithConfig("custom.yaml")  // Load specific config file

Configuration Examples

Development Setup

# fuego.yaml - Development
port: 3000
host: 127.0.0.1

dev:
  hot_reload: true
  watch_extensions:
    - .go
    - .templ
    - .css

middleware:
  logger: true
  recover: true

Production Setup

# fuego.yaml - Production
port: 8080
host: 0.0.0.0

dev:
  hot_reload: false

middleware:
  logger: true
  recover: true

With environment variables:

export FUEGO_PORT=8080
export FUEGO_LOG_LEVEL=warn
export GO_ENV=production

Docker Configuration

FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o main ./cmd/myapp

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/main .
COPY --from=builder /app/fuego.yaml .
COPY --from=builder /app/static ./static

ENV FUEGO_PORT=8080
ENV FUEGO_HOST=0.0.0.0
ENV GO_ENV=production

EXPOSE 8080
CMD ["./main"]

Kubernetes ConfigMap

apiVersion: v1
kind: ConfigMap
metadata:
  name: fuego-config
data:
  fuego.yaml: |
    port: 8080
    host: 0.0.0.0
    middleware:
      logger: true
      recover: true
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  template:
    spec:
      containers:
        - name: app
          env:
            - name: GO_ENV
              value: production
            - name: FUEGO_LOG_LEVEL
              value: warn
          volumeMounts:
            - name: config
              mountPath: /app/fuego.yaml
              subPath: fuego.yaml
      volumes:
        - name: config
          configMap:
            name: fuego-config

Accessing Configuration at Runtime

Access the current configuration from your app:

app := fuego.New()

// Get the full config
config := app.Config()
fmt.Printf("Running on port: %s\n", config.Port)
fmt.Printf("App directory: %s\n", config.AppDir)

// Get the server address
addr := config.Address()  // "0.0.0.0:3000"

Logger Configuration

Configure the request logger programmatically:

app := fuego.New()

// Configure logger with options
app.SetLogger(fuego.RequestLoggerConfig{
    ShowIP:        true,   // Show client IP address
    ShowUserAgent: true,   // Show user agent string
    ShowSize:      true,   // Show response size
    SkipStatic:    true,   // Don't log static file requests
    SkipPaths:     []string{"/health", "/ready", "/metrics"},
    Level:         fuego.LogLevelInfo,
})

// Disable logger entirely
app.DisableLogger()

// Re-enable with defaults
app.EnableLogger()

Log Output Format

The logger produces output like:

[12:34:56] GET /api/users 200 in 45ms (1.2KB)
[12:34:57] POST /api/tasks 201 in 123ms (256B)
[12:34:58] GET /v1/users → /api/users 200 in 52ms [rewrite]
[12:34:59] GET /api/admin 403 in 1ms [proxy]

With ShowIP and ShowUserAgent:

[12:34:56] 192.168.1.1 GET /api/users 200 in 45ms (1.2KB) Mozilla/5.0...

Validation

Fuego validates configuration at startup:

config := app.Config()

if err := config.Validate(); err != nil {
    log.Fatalf("invalid configuration: %v", err)
}

Validation checks:

Port is not empty
App directory is not empty
App directory exists (if specified)

If the app_dir doesn’t exist, Fuego will fail to start. Make sure the directory exists before running your application.

Best Practices

Use environment variables in production

Don’t commit production secrets or configuration to git. Use environment variables for deployment-specific settings.

Keep fuego.yaml for development defaults

Use fuego.yaml for sensible development defaults that all team members can share.

Override per environment

# Development
fuego dev

# Production
FUEGO_PORT=8080 GO_ENV=production ./myapp

Validate early

Check configuration at startup rather than failing later:

if err := app.Config().Validate(); err != nil {
    log.Fatal(err)
}

Next Steps

Quick Start

Get your first app running

Deployment

Deploy your Fuego app

Middleware

Configure middleware behavior

Performance

Optimize your configuration

Getting Started

Core Concepts

Frontend

Advanced

Guides

Configuration

Configuration Priority

fuego.yaml Reference

Configuration Options

Server Configuration

Directory Configuration

Development Configuration

Middleware Configuration

Environment Variables

Log Level Configuration

Programmatic Configuration

Available Options

Configuration Examples

Development Setup

Production Setup

Docker Configuration

Kubernetes ConfigMap

Accessing Configuration at Runtime

Logger Configuration

Log Output Format

Validation

Best Practices

Next Steps

Quick Start

Deployment

Middleware

Performance

Getting Started

Core Concepts

Frontend

Advanced

Guides

​Configuration Priority

​fuego.yaml Reference

​Configuration Options

​Server Configuration

​Directory Configuration

​Development Configuration

​Middleware Configuration

​Environment Variables

​Log Level Configuration

​Programmatic Configuration

​Available Options

​Configuration Examples

​Development Setup

​Production Setup

​Docker Configuration

​Kubernetes ConfigMap

​Accessing Configuration at Runtime

​Logger Configuration

​Log Output Format

​Validation

​Best Practices

​Next Steps

Quick Start

Deployment

Middleware

Performance

Configuration Priority

fuego.yaml Reference

Configuration Options

Server Configuration

Directory Configuration

Development Configuration

Middleware Configuration

Environment Variables

Log Level Configuration

Programmatic Configuration

Available Options

Configuration Examples

Development Setup

Production Setup

Docker Configuration

Kubernetes ConfigMap

Accessing Configuration at Runtime

Logger Configuration

Log Output Format

Validation

Best Practices

Next Steps