Lakta

https://vilsol.github.io/lakta/
Admin
Lakta is an opinionated Go microservice framework with automatic dependency injection, lifecycle...
Tokens:20,844
Snippets:274
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Implement SyncModule Start Method

Source: https://vilsol.github.io/lakta/guides/custom-module

Adds a Start method for modules that run long-lived servers.

```go
func (m *Module) Start(ctx context.Context) error {
    return m.server.ListenAndServe(m.config.Address()) // blocks
}
```

--------------------------------

### Create and Run a Lakta Runtime

Source: https://vilsol.github.io/lakta/core-concepts/runtime

Use `lakta.NewRuntime()` to create a runtime instance, passing in your modules. Call `.Run()` to start the service, which installs signal handlers and manages the module lifecycle. Errors during startup will cause the program to exit.

```go
if err := lakta.NewRuntime(module1, module2, module3, ...).Run(); err != nil {
    os.Exit(1)
}
```

--------------------------------

### Run the Application

Source: https://vilsol.github.io/lakta/getting-started/first-service

Executes the main Go application file to start the service.

```bash
go run ./main.go
```

--------------------------------

### Setup Fiber HTTP Server Module

Source: https://vilsol.github.io/lakta/modules/http

Configure and initialize the Fiber HTTP server module with custom defaults and routes. This setup includes other essential modules like configuration, logging, and tracing.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    otel.NewModule(),
    health.NewModule(),
    grpcclient.NewModule(
        grpcclient.WithName("data"),
        grpcclient.WithClient(v1.NewDataServiceClient),
    ),
    fiberserver.NewModule(
        fiberserver.WithDefaults(fiber.Config{
            ReadTimeout:  30 * time.Second,
            WriteTimeout: 30 * time.Second,
        }),
        fiberserver.WithRouter(registerRoutes),
    ),
)

```

--------------------------------

### Get Tracer Provider and Start Span

Source: https://vilsol.github.io/lakta/modules/otel

This example demonstrates how to obtain a TracerProvider from the injector and use it to start a new trace span. Ensure the OpenTelemetry module is registered before invoking this.

```go
tracer := do.MustInvoke[trace.TracerProvider](injector).Tracer("my-service")


ctx, span := tracer.Start(ctx, "operation-name")
deffer span.End()

```

--------------------------------

### Module Initialization Order Example

Source: https://vilsol.github.io/lakta/getting-started/lifecycle

Illustrates the sequential order of module initialization, including config loading and dependency initialization.

```plaintext
[sorted] config.Init() → tint.Init() → slog.Init() → otel.Init() → ...
```

--------------------------------

### Example YAML Configuration

Source: https://vilsol.github.io/lakta/guides/config-passthrough

Configuration file demonstrating how extra fields are passed through to the raw map.

```yaml

modules:
  http:
    fiber:
      default:
        host: "0.0.0.0"
        port: 8080
        # These fall into Raw and get decoded into fiber.Config:
        body_limit: 10485760
        read_timeout: "30s"
        write_timeout: "30s"
        enable_trusted_proxy_check: true

```

--------------------------------

### Setup gRPC Client Modules

Source: https://vilsol.github.io/lakta/modules/grpc-client

Configure and register multiple gRPC client modules with specific client constructors.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    otel.NewModule(),
    grpcclient.NewModule(
        grpcclient.WithName("data"),
        grpcclient.WithClient(v1.NewDataServiceClient),
    ),
    grpcclient.NewModule(
        grpcclient.WithName("orchestrator"),
        grpcclient.WithClient(v1.NewWorkflowServiceClient),
    ),
    myapp.NewModule(),
)

```

--------------------------------

### Install Optional Integrations

Source: https://vilsol.github.io/lakta/getting-started/installation

Install specific sub-packages to include additional functionality like logging, observability, or database drivers.

```bash
go get github.com/Vilsol/lakta/pkg/logging/tint
go get github.com/Vilsol/lakta/pkg/logging/slog
go get github.com/Vilsol/lakta/pkg/otel
go get github.com/Vilsol/lakta/pkg/http/fiber
go get github.com/Vilsol/lakta/pkg/grpc/server
go get github.com/Vilsol/lakta/pkg/grpc/client
go get github.com/Vilsol/lakta/pkg/db/drivers/pgx
go get github.com/Vilsol/lakta/pkg/health
go get github.com/Vilsol/lakta/pkg/workflows/temporal
```

--------------------------------

### Setup Lakta Logging Modules

Source: https://vilsol.github.io/lakta/modules/logging

Initializes the Lakta runtime with tint for formatted output and slog for standard library logging.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),   // provides slog.Handler
    slog.NewModule(),   // provides *slog.Logger
)

```

--------------------------------

### Install Lakta Core

Source: https://vilsol.github.io/lakta/getting-started/installation

Use this command to add the core Lakta library to your Go module.

```bash
go get github.com/Vilsol/lakta
```

--------------------------------

### Setup gRPC Server Module

Source: https://vilsol.github.io/lakta/modules/grpc-server

Initialize the Lakta runtime with the gRPC server module, passing service implementations and configuration.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    otel.NewModule(),
    health.NewModule(),
    grpcserver.NewModule(
        grpcserver.WithService(&v1.MyService_ServiceDesc, NewServer()),
    ),
)
```

--------------------------------

### Example CLI Flag Usage

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Demonstrates how to override configuration values using CLI flags with dot notation.

```text
./myapp --modules.grpc.server.default.port=9090
./myapp --app.debug=true

```

--------------------------------

### Multi-instance pgx Configuration Example

Source: https://vilsol.github.io/lakta/modules/database

Example configuration file structure for multiple pgx database instances, specifying DSN for primary and replica connections. This configuration is typically loaded by the config module.

```yaml
modules:
  db:
    pgx:
      primary:
        dsn: "postgres://user:pass@primary:5432/mydb"
      replica:
        dsn: "postgres://user:pass@replica:5432/mydb"

```

--------------------------------

### Register Workflows and Activities

Source: https://vilsol.github.io/lakta/modules/temporal

Register workflows and activities inline using `WithRegistrar`. This is part of the initial runtime setup.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    otel.NewModule(),
    health.NewModule(),
    grpcclient.NewModule(
        grpcclient.WithName("data"),
        grpcclient.WithClient(v1.NewDataServiceClient),
    ),
    temporal.NewModule(
        temporal.WithRegistrar(func(ctx context.Context, w worker.Worker) error {
            w.RegisterWorkflow(OrderWorkflow)
            w.RegisterActivity(UpdateOrderStatusActivity)
            return nil
        }),
    ),
    grpcserver.NewModule(
        grpcserver.WithService(&v1.WorkflowService_ServiceDesc, NewServer()),
    ),
)

```

--------------------------------

### Start Temporal Workflow from gRPC Handler

Source: https://vilsol.github.io/lakta/modules/temporal

The Temporal `client.Client` is available via dependency injection. This snippet demonstrates starting an order workflow from a gRPC handler, including error handling for client invocation and workflow execution.

```go
func (s *WorkflowServer) StartOrderWorkflow(ctx context.Context, req *v1.StartOrderWorkflowRequest) (*v1.StartOrderWorkflowResponse, error) {
    c, err := lakta.Invoke[client.Client](ctx)
    if err != nil {
        return nil, status.Error(codes.Internal, err.Error())
    }


    _, err = c.ExecuteWorkflow(ctx, client.StartWorkflowOptions{
        ID:        fmt.Sprintf("order-workflow-%s", req.GetOrderId()),
        TaskQueue: taskQueue,
    }, OrderWorkflow, req.GetOrderId())
    if err != nil {
        return nil, status.Error(codes.Internal, err.Error())
    }


    return &v1.StartOrderWorkflowResponse{}, nil
}

```

--------------------------------

### Environment Variable Mapping Example

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Illustrates how environment variables with a specific prefix map to nested configuration keys using double underscores for path separation.

```text
LAKTA_MODULES__GRPC__SERVER__DEFAULT__PORT=9090
  → modules.grpc.server.default.port


LAKTA_MODULES__DB__PGX__DEFAULT__MAX_OPEN_CONNS=50
  → modules.db.pgx.default.max_open_conns

```

--------------------------------

### NewMockSyncModule

Source: https://vilsol.github.io/lakta/reference/api-index

Creates a mock for a `SyncModule` with a `BlockStart` channel. This allows controlling the start behavior of synchronous modules in tests.

```APIDOC
## NewMockSyncModule

### Description
SyncModule mock with `BlockStart` chan.

### Function Signature
`NewMockSyncModule() *MockSyncModule`
```

--------------------------------

### Implement a Temporal Activity

Source: https://vilsol.github.io/lakta/modules/temporal

Activities can access dependency injection via `lakta.Invoke[T](ctx)`. This example shows how to invoke a gRPC client within an activity.

```go
func UpdateOrderStatusActivity(ctx context.Context, orderID string, status string) error {
    client, err := lakta.Invoke[v1.DataServiceClient](ctx)
    if err != nil {
        return err
    }
    _, err = client.UpdateOrderStatus(ctx, &v1.UpdateOrderStatusRequest{
        OrderId:   orderID,
        NewStatus: v1.OrderStatus(v1.OrderStatus_value["ORDER_STATUS_"+strings.ToUpper(status)]),
    })
    return err
}

```

--------------------------------

### Setup pgx Module in lakta Runtime

Source: https://vilsol.github.io/lakta/modules/database

Initialize the lakta runtime with the pgx module for PostgreSQL connectivity. Ensure other necessary modules like config, tint, slog, and your application module are also included.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    pgx.NewModule(),
    myapp.NewModule(),
)

```

--------------------------------

### Define Base Module Interface

Source: https://vilsol.github.io/lakta/core-concepts/modules

The fundamental Module interface requires Init and Shutdown methods for setup and cleanup.

```go
type Module interface {
    Init(ctx context.Context) error
    Shutdown(ctx context.Context) error
}
```

--------------------------------

### NewRuntime

Source: https://vilsol.github.io/lakta/reference/api-index

Creates and runs a new Lakta service runtime with the specified modules. This is the entry point for initializing and starting the application.

```APIDOC
## NewRuntime

### Description
Creates and runs the service with the provided modules.

### Function Signature
`NewRuntime(modules ...Module) *Runtime`

### Parameters
- **modules** (...Module) - Variadic list of modules to include in the runtime.
```

--------------------------------

### Unblock MockSyncModule Start

Source: https://vilsol.github.io/lakta/guides/testing

Close the BlockStart channel of a MockSyncModule to unblock its Start method. This is useful for controlling the flow of mock modules in tests.

```go
go func() {
    time.Sleep(100 * time.Millisecond)
    close(syncMock.BlockStart)
}()
```

--------------------------------

### Kubernetes Deployment Environment Variables

Source: https://vilsol.github.io/lakta/reference/env-vars

Example of setting environment variables in a Kubernetes deployment. Use `valueFrom` for secrets and `value` for direct configuration.

```yaml
# kubernetes deployment
env:
  - name: LAKTA_MODULES__DB__PGX__DEFAULT__DSN
    valueFrom:
      secretKeyRef:
        name: db-secret
        key: dsn
  - name: LAKTA_MODULES__OTEL__OTEL__DEFAULT__ENDPOINT
    value: "http://otel-collector:4317"
```

--------------------------------

### Logging at Different Levels with Slox

Source: https://vilsol.github.io/lakta/guides/context-logging

Shows examples of logging messages at debug, info, warning, and error levels using `slox` with structured fields. The context `ctx` must be available.

```go
slox.Debug(ctx, "cache miss", slog.String("key", key))
slox.Info(ctx, "server started", slog.String("addr", addr))
slox.Warn(ctx, "retry attempt", slog.Int("attempt", n))
slox.Error(ctx, "fatal query", slog.Any("err", err))
```

--------------------------------

### Runtime.Run

Source: https://vilsol.github.io/lakta/reference/api-index

Starts the Lakta runtime and blocks execution until the runtime is gracefully shut down. This method is essential for keeping the service alive and responsive.

```APIDOC
## Runtime.Run

### Description
Starts the runtime and blocks until shutdown.

### Method
`Run()`

### Parameters
None
```

--------------------------------

### Use SyncCtx for Runtime Context

Source: https://vilsol.github.io/lakta/core-concepts/modules

Embed SyncCtx when an interceptor set up during Init needs access to the runtime context, which is only available at Start time.

```go
type MyModule struct {
    lakta.SyncCtx
}


func (m *MyModule) Init(ctx context.Context) error {
    // register an interceptor that calls m.RuntimeCtx() later
    return nil
}
```

--------------------------------

### Integration test with RuntimeHarness

Source: https://vilsol.github.io/lakta/guides/testing

Use NewRuntimeHarness to start a full Runtime in a goroutine for integration testing. Ensure to call Shutdown() for clean termination.

```go
func TestMyModule_Start(t *testing.T) {
    rh := testkit.NewRuntimeHarness(t,
        config.NewModule(),
        slog.NewModule(),
        mymodule.NewModule(),
    )
    defer rh.Shutdown()


    // runtime is now running; test behavior
    // e.g. make an HTTP request, invoke a gRPC method
}
```

--------------------------------

### Harness.WithKoanf

Source: https://vilsol.github.io/lakta/reference/api-index

Seeds the koanf configuration within the test harness from an existing `koanf.Koanf` instance. Useful for complex pre-configured setups.

```APIDOC
## Harness.WithKoanf

### Description
Seed koanf config from a Koanf instance.

### Method
`WithKoanf(*koanf.Koanf) *Harness`

### Parameters
- **k** (*koanf.Koanf) - A `koanf.Koanf` instance to use for seeding configuration.
```

--------------------------------

### Define SyncModule Interface

Source: https://vilsol.github.io/lakta/core-concepts/modules

SyncModule is for long-running services that must block, like HTTP or gRPC servers. Its Start method is expected to block until shutdown.

```go
type SyncModule interface {
    Module
    Start(ctx context.Context) error
}
```

--------------------------------

### Handle Order Placement Route

Source: https://vilsol.github.io/lakta/guides/microservices-example

Defines a route handler for placing orders. It retrieves gRPC clients for the data and workflow services, creates an order using the data client, and then starts an order workflow using the orchestrator client. Error handling is included for each step. Requires Lakta's Invoke function to retrieve gRPC clients.

```go
func postOrder(c fiber.Ctx) error {
    dataClient, err := lakta.Invoke[v1.DataServiceClient](c.Context())
    if err != nil {
        return err
    }
    workflowClient, err := lakta.Invoke[v1.WorkflowServiceClient](c.Context())
    if err != nil {
        return err
    }


    resp, err := dataClient.CreateOrder(c.Context(), &v1.CreateOrderRequest{...})
    if err != nil {
        return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
    }


    if _, err := workflowClient.StartOrderWorkflow(c.Context(), &v1.StartOrderWorkflowRequest{
        OrderId: resp.GetOrder().GetId(),
    }); err != nil {
        return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
    }


    return c.JSON(fiber.Map{"order": resp.GetOrder()})
}

```

--------------------------------

### Initialize Configuration Module

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Sets up the configuration module with default directories and command-line arguments.

```go
config.NewModule(
    config.WithConfigDirs(".", "./config"),
    config.WithArgs(os.Args[1:]),
)

```

--------------------------------

### Initialize Lakta Runtime

Source: https://vilsol.github.io/lakta/guides/microservices-example

Sets up the Lakta runtime with various modules including configuration, logging, tracing, health checks, gRPC clients for data and orchestrator services, and an HTTP server using the Fiber framework. Ensure all necessary modules are imported.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    otel.NewModule(),
    health.NewModule(),
    grpcclient.NewModule(
        grpcclient.WithName("data"),
        grpcclient.WithClient(v1.NewDataServiceClient),
    ),
    grpcclient.NewModule(
        grpcclient.WithName("orchestrator"),
        grpcclient.WithClient(v1.NewWorkflowServiceClient),
    ),
    fiberserver.NewModule(
        fiberserver.WithDefaults(fiber.Config{
            ReadTimeout:  30 * time.Second,
            WriteTimeout: 30 * time.Second,
        }),
        fiberserver.WithRouter(registerRoutes),
    ),
)

```

--------------------------------

### RuntimeHarness.Shutdown

Source: https://vilsol.github.io/lakta/reference/api-index

Gracefully stops the Lakta runtime started by `NewRuntimeHarness`. This ensures all resources are cleaned up properly.

```APIDOC
## RuntimeHarness.Shutdown

### Description
Gracefully stop the runtime.

### Method
`Shutdown()`
```

--------------------------------

### Initialize Lakta Runtime and Modules

Source: https://vilsol.github.io/lakta/getting-started/first-service

Sets up the core Lakta runtime with configuration, logging, and HTTP server modules. Ensure the configuration and logging modules are initialized before the HTTP server module for proper dependency injection.

```go
package main


import (
    "os"

    "github.com/Vilsol/lakta/pkg/config"
    fiberserver "github.com/Vilsol/lakta/pkg/http/fiber"
    "github.com/Vilsol/lakta/pkg/lakta"
    "github.com/Vilsol/lakta/pkg/logging/slog"
    "github.com/Vilsol/lakta/pkg/logging/tint"
    "github.com/gofiber/fiber/v3"
)


func main() {
    runtime := lakta.NewRuntime(
        config.NewModule(
            config.WithConfigDirs(".", "./config"),
            config.WithArgs(os.Args[1:]),
        ),
        tint.NewModule(),
        slog.NewModule(),
        fiberserver.NewModule(
            fiberserver.WithRouter(registerRoutes),
        ),
    )


    if err := runtime.Run(); err != nil {
        os.Exit(1)
    }
}
```

--------------------------------

### Get

Source: https://vilsol.github.io/lakta/reference/api-index

Reads the current bound configuration value for a given type. This operation is atomic and zero-allocation.

```APIDOC
## Get

### Description
Read the current bound value (atomic, zero-alloc).

### Function Signature
`Get[T](ctx) *T`

### Parameters
- **ctx** (context.Context) - The context from which to retrieve the configuration.
```

--------------------------------

### Define and Provide a Service

Source: https://vilsol.github.io/lakta/getting-started/first-service

Defines a simple service and registers it with Lakta's dependency injection system. The service must be provided in the `Init` method of a module before it is needed by other modules, such as the HTTP server.

```go
type MyService struct{}


func (s *MyService) Greet() string { return "hello" }
```

```go
type MyModule struct{}


func NewMyModule() *MyModule { return &MyModule{} }


func (m *MyModule) Init(ctx context.Context) error {
    lakta.Provide(ctx, func(do.Injector) (*MyService, error) {
        return &MyService{}, nil
    })
    return nil
}


func (m *MyModule) Shutdown(ctx context.Context) error { return nil }
```

--------------------------------

### Basic Request Handling with Context-Aware Logging

Source: https://vilsol.github.io/lakta/guides/context-logging

Demonstrates how to use `slox.Info` and `slox.Error` within a request handler, passing context and structured fields. Ensure `slox` is imported.

```go
import (
    "log/slog"
    "github.com/Vilsol/slox"
)


func (m *MyModule) handleRequest(ctx context.Context, req *Request) {
    slox.Info(ctx, "handling request",
        slog.String("user_id", req.UserID),
        slog.Int("item_count", len(req.Items)),
    )


    if err := m.process(ctx, req); err != nil {
        slox.Error(ctx, "processing failed", slog.Any("err", err))
        return
    }


    slox.Info(ctx, "request complete")
}
```

--------------------------------

### Create and Run a Lakta Service

Source: https://vilsol.github.io/lakta

This snippet demonstrates how to initialize and run a complete Lakta service with various built-in modules, including configuration, logging, OpenTelemetry, health checks, gRPC client, and an HTTP server using Fiber.

```go
func main() {
    if err := lakta.NewRuntime(
        config.NewModule(
            config.WithConfigDirs(".", "./config"),
            config.WithArgs(os.Args[1:]),
        ),
        tint.NewModule(),
        slog.NewModule(),
        otel.NewModule(),
        health.NewModule(),
        grpcclient.NewModule(
            grpcclient.WithName("data"),
            grpcclient.WithClient(v1.NewDataServiceClient),
        ),
        fiberserver.NewModule(
            fiberserver.WithDefaults(fiber.Config{ReadTimeout: 30 * time.Second}),
            fiberserver.WithRouter(registerRoutes),
        ),
    ).Run(); err != nil {
        os.Exit(1)
    }
}
```

--------------------------------

### Initialize Runtime with Health Module

Source: https://vilsol.github.io/lakta/modules/health

Sets up the application runtime, including the health module, which registers health endpoints on the HTTP server.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    slog.NewModule(),
    fiber.NewModule(),  // health endpoints are registered on the HTTP server
    health.NewModule(),
    myapp.NewModule(),
)

```

--------------------------------

### Initialize Configuration Harness with Data

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Use testkit.NewHarness to provide configuration data directly for testing, bypassing the file system. This is useful for setting up specific test scenarios.

```go
h := testkit.NewHarness(t).WithData(map[string]any{
    "app": map[string]any{"workers": 8, "debug": true},
})
_ = h
```

--------------------------------

### Create mock modules

Source: https://vilsol.github.io/lakta/guides/testing

Instantiate mock modules for dependency substitution when real implementations are not needed. Supports basic, SyncModule, and AsyncModule variants.

```go
mock := testkit.NewMockModule()          // basic Module
syncMock := testkit.NewMockSyncModule()  // SyncModule, has BlockStart chan
asyncMock := testkit.NewMockAsyncModule()
```

--------------------------------

### Initialize Data Service Runtime

Source: https://vilsol.github.io/lakta/guides/microservices-example

Configures the data service runtime with necessary modules including PostgreSQL, gRPC, and observability.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    otel.NewModule(),
    health.NewModule(),
    pgx.NewModule(pgx.WithName("main")),
    sql.NewModule(),
    grpcserver.NewModule(
        grpcserver.WithService(&v1.DataService_ServiceDesc, NewServer()),
    ),
)
```

--------------------------------

### Configure Configuration File Search Paths and Name

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Specifies custom directories and a base name for configuration files.

```go
config.NewModule(
    config.WithConfigDirs(".", "./config", "/etc/myapp"),
    config.WithConfigName("myapp"), // default: "lakta"
)

```

--------------------------------

### Injecting Request ID into Context Logger

Source: https://vilsol.github.io/lakta/guides/context-logging

Example of middleware function that enriches the logger in the context with a `request_id`. This logger can then be used by downstream functions.

```go
func withRequestID(ctx context.Context, id string) context.Context {
    logger := slox.FromContext(ctx).With(slog.String("request_id", id))
    return slox.WithContext(ctx, logger)
}
```

--------------------------------

### Implement Module Configuration

Source: https://vilsol.github.io/lakta/guides/custom-module

Defines the configuration struct and functional options for the module.

```go
package mymodule


import "github.com/knadh/koanf/v2"


type Config struct {
    Host    string `koanf:"host"`
    Port    int    `koanf:"port"`
    Timeout string `koanf:"timeout"`
}


type Option func(*Config)


func WithName(name string) Option {
    return func(c *Config) { c.name = name }
}


func WithHost(host string) Option {
    return func(c *Config) { c.Host = host }
}


// Domain method — produces a library-specific type
func (c *Config) Address() string {
    return fmt.Sprintf("%s:%d", c.Host, c.Port)
}
```

--------------------------------

### Configuring Multiple Fiber Server Instances

Source: https://vilsol.github.io/lakta/modules/http

Set up distinct instances of the Fiber server, each with a unique name, router, and configuration. This allows for running multiple servers on different ports.

```go
fiberserver.NewModule(fiberserver.WithName("admin"), fiberserver.WithRouter(adminRoutes)),
fiberserver.NewModule(fiberserver.WithName("public"), fiberserver.WithRouter(publicRoutes)),

```

--------------------------------

### Implement Module Lifecycle

Source: https://vilsol.github.io/lakta/guides/custom-module

Defines the module struct and lifecycle methods including initialization and configuration loading.

```go
package mymodule


type Module struct {
    lakta.NamedBase
    config *Config
}


func NewModule(opts ...Option) *Module {
    cfg := &Config{Host: "localhost", Port: 8080}
    for _, o := range opts { o(cfg) }
    m := &Module{config: cfg}
    m.NamedBase = lakta.NewNamedBase(cfg.name)
    return m
}


func (m *Module) ConfigPath() string {
    return "modules.mymodule." + m.Name()
}


func (m *Module) LoadConfig(k *koanf.Koanf) error {
    return k.UnmarshalWithConf("", m.config, koanf.UnmarshalConf{Tag: "koanf"})
}


func (m *Module) Init(ctx context.Context) error {
    svc := NewMyService(m.config.Address())
    lakta.Provide(ctx, func(do.Injector) (*MyService, error) {
        return svc, nil
    })
    return nil
}


func (m *Module) Shutdown(ctx context.Context) error {
    return nil
}
```

--------------------------------

### WithConfigDirs

Source: https://vilsol.github.io/lakta/reference/api-index

Sets the directories to search for configuration files. This option is used when initializing the configuration module.

```APIDOC
## WithConfigDirs

### Description
Set search directories for config files.

### Function Signature
`WithConfigDirs(dirs ...string) Option`

### Parameters
- **dirs** (...string) - A variadic list of directory paths to search for configuration files.
```

--------------------------------

### WithConfigName

Source: https://vilsol.github.io/lakta/reference/api-index

Sets the base name for configuration files. The default name is 'lakta'.

```APIDOC
## WithConfigName

### Description
Set config file base name (default: `"lakta"`).

### Function Signature
`WithConfigName(name string) Option`

### Parameters
- **name** (string) - The base name for configuration files.
```

--------------------------------

### React to Configuration Changes

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Subscribes to changes in a bound configuration struct and executes a callback function when updates occur.

```go
type AppConfig struct{ Workers int }
binding := config.GetBinding[AppConfig](context.Background())
binding.OnChange(func(cfg *AppConfig) {
    // called after the new value is stored — config.Get returns new value here too
    fmt.Printf("workers updated: %d\n", cfg.Workers)
})

```

--------------------------------

### Configure Multi-instance gRPC Servers

Source: https://vilsol.github.io/lakta/modules/grpc-server

Register multiple gRPC server instances with distinct names to manage different service groups within the same runtime.

```go
grpcserver.NewModule(
    grpcserver.WithName("internal"),
    grpcserver.WithService(&v1.InternalService_ServiceDesc, NewInternalServer()),
),
grpcserver.NewModule(
    grpcserver.WithName("public"),
    grpcserver.WithService(&v1.PublicService_ServiceDesc, NewPublicServer()),
),
```

--------------------------------

### Instantiate Multiple gRPC Clients with Names

Source: https://vilsol.github.io/lakta/core-concepts/multi-instance

Use grpcclient.NewModule with grpcclient.WithName to create distinct gRPC client instances for different services. This enables separate configurations for each client.

```go
lakta.NewRuntime(
    grpcclient.NewModule(grpcclient.WithName("payments")),
    grpcclient.NewModule(grpcclient.WithName("notifications")),
)
```

--------------------------------

### Initialize Orchestrator Service Runtime

Source: https://vilsol.github.io/lakta/guides/microservices-example

Configures the orchestrator service with Temporal worker registration and gRPC client/server modules.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    otel.NewModule(),
    health.NewModule(),
    grpcclient.NewModule(
        grpcclient.WithName("data"),
        grpcclient.WithClient(v1.NewDataServiceClient),
    ),
    temporal.NewModule(
        temporal.WithRegistrar(func(ctx context.Context, w worker.Worker) error {
            w.RegisterWorkflow(SingleOrderWorkflow)
            w.RegisterActivity(UpdateOrderStatusActivity)
            return nil
        }),
    ),
    grpcserver.NewModule(
        grpcserver.WithService(&v1.WorkflowService_ServiceDesc, NewServer()),
    ),
)
```

--------------------------------

### Generate Module Configuration Paths

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Uses `config.ModulePath` to construct consistent configuration key paths for different module categories and types.

```go
config.ModulePath(config.CategoryGRPC, "server", "default")   // "modules.grpc.server.default"
config.ModulePath(config.CategoryGRPC, "server", "internal")  // "modules.grpc.server.internal"
config.ModulePath(config.CategoryDB,   "pgx",    "main")      // "modules.db.pgx.main"

```

--------------------------------

### Configure Multiple pgx Instances

Source: https://vilsol.github.io/lakta/modules/database

Define and name multiple pgx modules for distinct database connections, such as a primary and a replica. This allows for granular control over different database endpoints.

```go
pgx.NewModule(pgx.WithName("primary")),
pgx.NewModule(pgx.WithName("replica")),

```

--------------------------------

### Initialize OpenTelemetry Module

Source: https://vilsol.github.io/lakta/modules/otel

This snippet shows how to initialize the OpenTelemetry module within the lakta runtime. It should be placed after the logger module and before application-specific modules.

```go
lakta.NewRuntime(
    config.NewModule(
        config.WithConfigDirs(".", "./config"),
        config.WithArgs(os.Args[1:]),
    ),
    tint.NewModule(),
    slog.NewModule(),
    otel.NewModule(),   // after logger, before app modules
)

```

--------------------------------

### Configuration and Naming Interfaces

Source: https://vilsol.github.io/lakta/core-concepts/modules

Interfaces for modules that load configuration and support multiple instances.

```APIDOC
## Configuration and Naming Interfaces

### Configurable

Modules that load from the config file:

```go
type Configurable interface {
    ConfigPath() string
    LoadConfig(*koanf.Koanf) error
}
```

The runtime calls `LoadConfig` automatically before `Init` using the sub-tree at `ConfigPath()`.

### NamedModule

Enables multiple instances of the same module type:

```go
type NamedModule interface {
    Name() string
}
```

Embed `lakta.NamedBase` and call `NewNamedBase(name)` for a ready-made implementation. See Multi-instance Modules.
```

--------------------------------

### Test hot-reloading with Harness

Source: https://vilsol.github.io/lakta/guides/testing

Simulate hot-reloading by creating a Harness, obtaining a ReloadNotifier, and firing a reload event with new configuration data.

```go
h := testkit.NewHarness(t).WithData(initialData)
notifier := do.MustInvoke[*config.ReloadNotifier](lakta.GetInjector(h.Ctx()))
notifier.FireReload(newKoanf)  // triggers all registered OnReload callbacks
```

--------------------------------

### Implement a Configurable Module

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Implement the Configurable interface to allow the runtime to populate your module's configuration struct before initialization. The LoadConfig method handles unmarshalling the configuration.

```go
type Config struct {
    Workers int    `koanf:"workers"
    Queue   string `koanf:"queue"
}

type Module struct{ config Config }


func (m *Module) ConfigPath() string {
    return config.ModulePath("workflows", "processor", "default")
}


func (m *Module) LoadConfig(k *koanf.Koanf) error {
    return config.UnmarshalKoanf(&m.config, k, "")
}


func (m *Module) Init(ctx context.Context) error {
    // m.config is fully populated here
    return nil
}
```

--------------------------------

### Enable CLI Flag Overrides

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Configures the module to accept configuration values from command-line arguments.

```go
config.WithArgs(os.Args[1:])

```

--------------------------------

### NewModule

Source: https://vilsol.github.io/lakta/reference/api-index

Creates a new configuration module for Lakta. This module allows for setting up and managing application configuration.

```APIDOC
## NewModule

### Description
Creates a new configuration module.

### Function Signature
`NewModule(opts ...Option) *Module`

### Parameters
- **opts** (...Option) - Variadic list of configuration options for the module.
```

--------------------------------

### Logging tint Module Configuration

Source: https://vilsol.github.io/lakta/reference/config-schema

Configure the tint logging module. Specify the time format for log entries.

```yaml
modules:
  logging:
    tint:
      default:
        time_format: "2006-01-02T15:04:05Z07:00"

```

--------------------------------

### Invoke Dependency during Module Init

Source: https://vilsol.github.io/lakta/core-concepts/dependency-injection

Retrieve the injector explicitly and invoke a dependency when wiring modules together in the `Init` phase.

```go
func (m *MyModule) Init(ctx context.Context) error {
    injector := lakta.GetInjector(ctx)
    dep := do.MustInvoke[*Dependency](injector)
    m.svc = NewMyService(dep)
    return nil
}

```

--------------------------------

### Configure Multiple gRPC Connections

Source: https://vilsol.github.io/lakta/modules/grpc-client

Define separate configuration blocks for multiple gRPC clients, each with a unique name and target.

```go
grpcclient.NewModule(
    grpcclient.WithName("data"),
    grpcclient.WithClient(v1.NewDataServiceClient),
),
grpcclient.NewModule(
    grpcclient.WithName("orchestrator"),
    grpcclient.WithClient(v1.NewWorkflowServiceClient),
),

```

```yaml
modules:
  grpc:
    client:
      data:
        target: "data-svc:50051"
        insecure: true
      orchestrator:
        target: "orchestrator-svc:50052"
        insecure: true

```

--------------------------------

### Define Module File Structure

Source: https://vilsol.github.io/lakta/guides/custom-module

The standard directory layout for a custom module.

```text
pkg/mymodule/
├── config.go   # Config struct, options, domain methods
└── module.go   # Module struct, lifecycle methods
```

--------------------------------

### Default Module Configuration Structure

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Shows the standard hierarchical structure for module configuration keys.

```yaml
modules:
  grpc:
    server:
      default:
        host: "0.0.0.0"
        port: 50051
      internal:
        host: "127.0.0.1"
        port: 50052
    client:
      data:
        target: "data-service:50051"
  db:
    pgx:
      main:
        dsn: "postgres://localhost/mydb"

```

--------------------------------

### Add Service Module to Runtime

Source: https://vilsol.github.io/lakta/getting-started/first-service

Demonstrates the order in which modules should be added to the Lakta runtime. The custom module providing `*MyService` is added before the `fiberserver` module to ensure the service is available for dependency injection in route handlers.

```go
lakta.NewRuntime(
    config.NewModule(...),
    tint.NewModule(),
    slog.NewModule(),
    NewMyModule(),        // registers *MyService
    fiberserver.NewModule(
        fiberserver.WithRouter(registerRoutes),
    ),
)
```

--------------------------------

### Unit test a module with Harness

Source: https://vilsol.github.io/lakta/guides/testing

Use NewHarness to create a DI injector for testing a single module's Init function. Provide configuration data and DI dependencies as needed.

```go
func TestMyModule_Init(t *testing.T) {
    h := testkit.NewHarness(t)


    // Provide config if the module is Configurable
    h = h.WithData(map[string]any{
        "modules.mymodule.default.host": "localhost",
        "modules.mymodule.default.port": 8080,
    })


    // Provide any DI dependencies the module needs
    testkit.WithProvider[*pgxpool.Pool](h, func(do.Injector) (*pgxpool.Pool, error) {
        return fakePool, nil
    })


    m := mymodule.NewModule()
    testza.AssertNoError(t, m.Init(h.Ctx()))


    // Invoke what the module registered
    svc := do.MustInvoke[*mymodule.MyService](lakta.GetInjector(h.Ctx()))
    testza.AssertNotNil(t, svc)
}
```

--------------------------------

### Register HTTP Routes

Source: https://vilsol.github.io/lakta/getting-started/first-service

Defines the HTTP routes for the application using the Fiber framework. Dependency injection is available within handlers via `lakta.Invoke`.

```go
func registerRoutes(app *fiber.App) {
    app.Get("/hello", handleHello)
}


func handleHello(c fiber.Ctx) error {
    svc, err := lakta.Invoke[*MyService](c.Context())
    if err != nil {
        return err
    }
    return c.JSON(fiber.Map{"message": svc.Greet()})
}
```

--------------------------------

### Implement gRPC Service

Source: https://vilsol.github.io/lakta/modules/grpc-server

Define a gRPC service implementation by embedding the Unimplemented*Server type and using lakta.Invoke to access dependencies within handlers.

```go
type MyServer struct {
    v1.UnimplementedMyServiceServer
}


func NewServer() *MyServer { return &MyServer{} }


func (s *MyServer) GetThing(ctx context.Context, req *pb.GetThingRequest) (*pb.GetThingResponse, error) {
    svc, err := lakta.Invoke[*MyService](ctx)
    if err != nil {
        return nil, err
    }
    return svc.GetThing(ctx, req.Id)
}
```

--------------------------------

### Register HTTP Routes with DI

Source: https://vilsol.github.io/lakta

This Go function registers routes for a Fiber HTTP server. It shows how to use Lakta's dependency injection to retrieve a gRPC client within a route handler.

```go
func registerRoutes(app *fiber.App) {
    app.Get("/orders/:id", func(c fiber.Ctx) error {
        client, err := lakta.Invoke[v1.DataServiceClient](c.Context())
        if err != nil {
            return err
        }
        resp, err := client.GetOrder(c.Context(), &v1.GetOrderRequest{Id: c.Params("id")})
        if err != nil {
            return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
        }
        return c.JSON(resp.GetOrder())
    })
}
```

--------------------------------

### NewRuntimeHarness

Source: https://vilsol.github.io/lakta/reference/api-index

Creates a full Lakta runtime within a goroutine for integration testing. This allows testing the complete runtime behavior.

```APIDOC
## NewRuntimeHarness

### Description
Full runtime in goroutine.

### Function Signature
`NewRuntimeHarness(t *testing.T, modules ...Module) *RuntimeHarness`

### Parameters
- **t** (*testing.T) - The testing object.
- **modules** (...Module) - Variadic list of modules to include in the runtime.
```

--------------------------------

### NewMockProviderModule

Source: https://vilsol.github.io/lakta/reference/api-index

Creates a mock module that registers a dependency injection provider. Useful for testing DI scenarios.

```APIDOC
## NewMockProviderModule

### Description
Module mock that registers a DI provider.

### Function Signature
`NewMockProviderModule() *MockProviderModule`
```

--------------------------------

### WithEnvPrefix

Source: https://vilsol.github.io/lakta/reference/api-index

Sets a prefix for environment variables used to override configuration. The default prefix is 'LAKTA_'.

```APIDOC
## WithEnvPrefix

### Description
Set env var prefix (default: `"LAKTA_"`).

### Function Signature
`WithEnvPrefix(prefix string) Option`

### Parameters
- **prefix** (string) - The prefix for environment variables.
```

--------------------------------

### Register Provider in Lakta Module

Source: https://vilsol.github.io/lakta/core-concepts/dependency-injection

Register a service provider within a Lakta module's Init function. Providers are constructed on first invocation.

```go
func (m *MyModule) Init(ctx context.Context) error {
    lakta.Provide(ctx, func(i do.Injector) (*MyService, error) {
        return &MyService{}, nil
    })
    return nil
}

```

--------------------------------

### NewMockModule

Source: https://vilsol.github.io/lakta/reference/api-index

Creates a basic mock for a Lakta module. Useful for stubbing module behavior in tests.

```APIDOC
## NewMockModule

### Description
Basic module mock.

### Function Signature
`NewMockModule() *MockModule`
```

--------------------------------

### Registering Routes for Fiber App

Source: https://vilsol.github.io/lakta/modules/http

Define all HTTP routes for the Fiber application within a single function. This function receives the fully initialized *fiber.App instance.

```go
func registerRoutes(app *fiber.App) {
    app.Get("/items", listItems)
    app.Get("/items/:id", getItem)
    app.Post("/items", createItem)
}

```

--------------------------------

### Bind Application Configuration Struct

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Registers a typed struct for configuration binding and automatic hot-reloading within the runtime.

```go
type AppConfig struct {
    Workers int  `koanf:"workers"
    Debug   bool `koanf:"debug"
}


lakta.NewRuntime(
    config.NewModule(config.WithConfigDirs(".")),
    config.Bind[AppConfig]("app"),
)

```

--------------------------------

### Implement NamedBase in Custom Modules

Source: https://vilsol.github.io/lakta/core-concepts/multi-instance

Custom modules can implement the NamedModule interface by embedding lakta.NamedBase. The NewMyModule constructor initializes NamedBase with a given name, which is used for configuration and DI registration.

```go
type MyModule struct {
    lakta.NamedBase
}


func NewMyModule(name string) *MyModule {
    m := &MyModule{}
    m.NamedBase = lakta.NewNamedBase(name)
    return m
}
```

--------------------------------

### Define Config with Raw Field

Source: https://vilsol.github.io/lakta/guides/config-passthrough

Use the koanf:",remain" tag on a map field to capture all configuration keys not explicitly defined in the struct.

```go

type Config struct {
    Host string         `koanf:"host"`
    Port int            `koanf:"port"`
    Raw  map[string]any `koanf:",remain"`
}

```

--------------------------------

### OpenTelemetry (otel) Module Configuration

Source: https://vilsol.github.io/lakta/reference/config-schema

Configure the OpenTelemetry module. Set service details, endpoint, protocol, sampling rate, and enabled signals.

```yaml
modules:
  otel:
    otel:
      default:
        service_name: "lakta"
        service_version: ""
        service_namespace: ""
        environment: ""
        endpoint: ""
        protocol: "grpc"
        insecure: false
        headers: {}
        sample_rate: 1
        metric_interval: "1m0s"
        runtime_interval: "1s"
        enabled: true
        signals: []  # default: [traces metrics logs]

```

--------------------------------

### Configure Named gRPC Client Instances

Source: https://vilsol.github.io/lakta/core-concepts/multi-instance

Configuration for named gRPC client instances is organized under their respective names within the 'grpc.client' section. Specify the target for each named client.

```yaml
modules:
  grpc:
    client:
      payments:
        target: "payments-svc:50051"
      notifications:
        target: "notifications-svc:50051"
```

--------------------------------

### Bind

Source: https://vilsol.github.io/lakta/reference/api-index

Binds a configuration sub-tree to a typed struct and registers it as a module. This allows typed access to configuration values.

```APIDOC
## Bind

### Description
Bind a config sub-tree to a typed struct; adds as a module.

### Function Signature
`Bind[T](path ...string) Module`

### Parameters
- **path** (...string) - Optional path segments to specify the sub-tree to bind.
```

--------------------------------

### Implement Configuration Validation

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Implement the Validate() error method on your configuration struct to ensure data integrity after unmarshalling. Failures during initialization will abort the process, while reload failures preserve the old configuration.

```go
type AppConfig struct{ Workers int }


func (c *AppConfig) Validate() error {
    if c.Workers <= 0 {
        return errors.New("workers must be positive")
    }
    return nil
}
```

--------------------------------

### Decode Raw Config to Library Struct

Source: https://vilsol.github.io/lakta/guides/config-passthrough

Utilize mapstructure to decode the captured raw configuration map into the target library's configuration struct.

```go

import "github.com/mitchellh/mapstructure"


func (c *Config) ToFiberConfig() fiber.Config {
    cfg := fiber.Config{}
    _ = mapstructure.Decode(c.Raw, &cfg)
    return cfg
}

```

--------------------------------

### WithArgs

Source: https://vilsol.github.io/lakta/reference/api-index

Enables overriding configuration values using command-line flags. It processes arguments from `os.Args[1:]`.

```APIDOC
## WithArgs

### Description
Enable CLI flag overrides (`os.Args[1:]`).

### Function Signature
`WithArgs(args []string) Option`

### Parameters
- **args** ([]string) - A slice of strings representing command-line arguments to process.
```

--------------------------------

### Bind Nested Configuration Paths

Source: https://vilsol.github.io/lakta/core-concepts/configuration

Binds a configuration struct to a specific nested path within the configuration tree.

```go
type ServerConfig struct{}
config.Bind[ServerConfig]("modules", "grpc", "server", "default")

```

--------------------------------

### Context-Aware Logging with Slox

Source: https://vilsol.github.io/lakta/modules/logging

Logs messages with context-carried loggers, ensuring correct fields are included. Use for informational or error messages.

```go
slox.Info(ctx, "request received", slog.String("path", r.URL.Path))
slox.Error(ctx, "query failed", slog.Any("err", err))

```

--------------------------------

### Invoke Service in HTTP (Fiber) Handler

Source: https://vilsol.github.io/lakta/core-concepts/dependency-injection

Consume DI in Fiber HTTP handlers using `lakta.Invoke` with the context from the Fiber context.

```go
// HTTP handler (Fiber)
func handleGet(c fiber.Ctx) error {
    svc, err := lakta.Invoke[*MyService](c.Context())
    if err != nil {
        return err
    }
    return c.JSON(svc.Get())
}

```

--------------------------------

### Register Typed gRPC Client

Source: https://vilsol.github.io/lakta/core-concepts/dependency-injection

Register a typed gRPC client using `grpcclient.WithClient`. Usage involves invoking the interface type.

```go
// Registration (in NewRuntime)
grpcclient.NewModule(
    grpcclient.WithName("data"),
    grpcclient.WithClient(v1.NewDataServiceClient),
)


// Usage in any handler
client, err := lakta.Invoke[v1.DataServiceClient](ctx)

```

--------------------------------

### Execute Workflow and Activity in Orchestrator

Source: https://vilsol.github.io/lakta/guides/microservices-example

Triggers a Temporal workflow via gRPC and uses an activity to communicate back to the data service.

```go
// gRPC handler triggers a workflow
func (s *WorkflowServer) StartOrderWorkflow(ctx context.Context, req *v1.StartOrderWorkflowRequest) (*v1.StartOrderWorkflowResponse, error) {
    c, err := lakta.Invoke[client.Client](ctx)
    if err != nil {
        return nil, status.Error(codes.Internal, err.Error())
    }
    _, err = c.ExecuteWorkflow(ctx, client.StartWorkflowOptions{
        ID:        fmt.Sprintf("order-sequence-workflow-%s", req.GetOrderId()),
        TaskQueue: taskQueue,
    }, SingleOrderWorkflow, req.GetOrderId())
    // ...
}


// Activity calls back into the data service
func UpdateOrderStatusActivity(ctx context.Context, orderID string, newStatus v1.OrderStatus) error {
    client, err := lakta.Invoke[v1.DataServiceClient](ctx)
    if err != nil {
        return err
    }
    _, err = client.UpdateOrderStatus(ctx, &v1.UpdateOrderStatusRequest{
        OrderId:   orderID,
        NewStatus: newStatus,
    })
    return err
}
```

--------------------------------

### Implement Dependent Interface

Source: https://vilsol.github.io/lakta/core-concepts/modules

The Dependent interface declares required and optional types a module needs before its Init method runs. Missing required dependencies cause startup errors, while optional ones are ignored if unavailable.

```go
type Dependent interface {
    Dependencies() (required, optional []reflect.Type)
}
```

```go
func (m *MyModule) Dependencies() (required, optional []reflect.Type) {
    required = []reflect.Type{reflect.TypeOf((*pgxpool.Pool)(nil))}
    optional = []reflect.Type{reflect.TypeOf((*slog.Logger)(nil))}
    return
}
```

--------------------------------

### PostgreSQL (pgx) Module Configuration

Source: https://vilsol.github.io/lakta/reference/config-schema

Configure the PostgreSQL database module using pgx. Requires a DSN and allows setting connection limits, log level, and health check.

```yaml
modules:
  db:
    pgx:
      default:
        dsn: ""  # required
        max_open_conns: 10
        log_level: "info"  # one of: trace, debug, info, warn, error, none
        health_check: false

```

--------------------------------

### Health Module Configuration

Source: https://vilsol.github.io/lakta/reference/config-schema

Configure the health module with component name and version.

```yaml
modules:
  health:
    health:
      default:
        component_name: ""
        component_version: ""

```
Tokens:
Raw