story(issue-85): rest increase test coverage (#89)

Author: Zaba505

README.md

@@ -2,7 +2,7 @@
 
 [![Go Reference](https://pkg.go.dev/badge/github.com/z5labs/humus.svg)](https://pkg.go.dev/github.com/z5labs/humus)
 [![Go Report Card](https://goreportcard.com/badge/github.com/z5labs/humus)](https://goreportcard.com/report/github.com/z5labs/humus)
-![Coverage](https://img.shields.io/badge/Coverage-39.0%25-yellow)
+![Coverage](https://img.shields.io/badge/Coverage-71.5%25-brightgreen)
 [![build](https://github.com/z5labs/humus/actions/workflows/build.yaml/badge.svg)](https://github.com/z5labs/humus/actions/workflows/build.yaml)
 
 **humus one stop shop framework for all Z5Labs projects in Go.**

buildcontext/buildcontext.go

@@ -0,0 +1,240 @@
+// Copyright (c) 2025 Z5Labs and Contributors
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+package humus
+
+import (
+	"bytes"
+	"context"
+	_ "embed"
+	"errors"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"github.com/z5labs/humus/config"
+	"github.com/z5labs/humus/internal"
+	"github.com/z5labs/humus/internal/detector"
+
+	bedrockcfg "github.com/z5labs/bedrock/config"
+	"go.opentelemetry.io/contrib/instrumentation/runtime"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/exporters/stdout/stdoutlog"
+	"go.opentelemetry.io/otel/log/global"
+	"go.opentelemetry.io/otel/sdk/log"
+	"go.opentelemetry.io/otel/sdk/metric"
+	"go.opentelemetry.io/otel/sdk/resource"
+	"go.opentelemetry.io/otel/sdk/trace"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+//go:embed default_config.yaml
+var defaultConfig []byte
+
+// DefaultConfig
+func DefaultConfig() bedrockcfg.Source {
+	return internal.ConfigSource(bytes.NewReader(defaultConfig))
+}
+
+// Config
+type Config struct {
+	OTel config.OTel `config:"otel"`
+}
+
+// InitializeOTel implements the [appbuilder.OTelInitializer] interface.
+func (cfg Config) InitializeOTel(ctx context.Context) error {
+	conn, err := newClientConn(cfg.OTel.OTLP)
+	if err != nil {
+		return err
+	}
+
+	r, err := detectResource(ctx, cfg.OTel.Resource)
+	if err != nil {
+		return err
+	}
+
+	initers := []initializer{
+		traceProviderInitializer{
+			cfg:         cfg.OTel.Trace,
+			cc:          conn,
+			r:           r,
+			newExporter: otlptracegrpc.New,
+		},
+		meterProviderInitializer{
+			cfg:         cfg.OTel.Metric,
+			cc:          conn,
+			r:           r,
+			newExporter: otlpmetricgrpc.New,
+		},
+		logProviderInitializer{
+			cfg:         cfg.OTel.Log,
+			cc:          conn,
+			r:           r,
+			newExporter: otlploggrpc.New,
+		},
+	}
+
+	for _, initer := range initers {
+		err := initer.Init(ctx)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func newClientConn(cfg config.OTLP) (*grpc.ClientConn, error) {
+	if !cfg.Enabled {
+		return nil, nil
+	}
+	return grpc.NewClient(
+		cfg.Target,
+		// TODO: support secure transport credentials
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+	)
+}
+
+func detectResource(ctx context.Context, cfg config.Resource) (*resource.Resource, error) {
+	return resource.Detect(
+		ctx,
+		detector.TelemetrySDK(),
+		detector.Host(),
+		detector.ServiceName(cfg.ServiceName),
+		detector.ServiceVersion(cfg.ServiceVersion),
+	)
+}
+
+var ErrOTLPMustBeEnabled = errors.New("missing otlp client conn")
+
+type initializer interface {
+	Init(context.Context) error
+}
+
+type traceProviderInitializer struct {
+	cfg         config.Trace
+	cc          *grpc.ClientConn
+	r           *resource.Resource
+	newExporter func(context.Context, ...otlptracegrpc.Option) (*otlptrace.Exporter, error)
+}
+
+func (tpi traceProviderInitializer) Init(ctx context.Context) error {
+	if !tpi.cfg.Enabled {
+		return nil
+	}
+	if tpi.cc == nil {
+		return fmt.Errorf("can not enable otel tracing: %w", ErrOTLPMustBeEnabled)
+	}
+
+	exp, err := tpi.newExporter(ctx, otlptracegrpc.WithGRPCConn(tpi.cc))
+	if err != nil {
+		return err
+	}
+
+	bsp := trace.NewBatchSpanProcessor(
+		exp,
+		trace.WithBatchTimeout(tpi.cfg.BatchTimeout),
+	)
+
+	tp := trace.NewTracerProvider(
+		trace.WithSpanProcessor(bsp),
+		trace.WithSampler(trace.TraceIDRatioBased(tpi.cfg.Sampling)),
+		trace.WithResource(tpi.r),
+	)
+	otel.SetTracerProvider(tp)
+	return nil
+}
+
+type meterProviderInitializer struct {
+	cfg         config.Metric
+	cc          *grpc.ClientConn
+	r           *resource.Resource
+	newExporter func(context.Context, ...otlpmetricgrpc.Option) (*otlpmetricgrpc.Exporter, error)
+}
+
+func (mpi meterProviderInitializer) Init(ctx context.Context) error {
+	if !mpi.cfg.Enabled {
+		return nil
+	}
+	if mpi.cc == nil {
+		return fmt.Errorf("can not enable otel metering: %w", ErrOTLPMustBeEnabled)
+	}
+
+	exp, err := mpi.newExporter(ctx, otlpmetricgrpc.WithGRPCConn(mpi.cc))
+	if err != nil {
+		return err
+	}
+
+	pr := metric.NewPeriodicReader(
+		exp,
+		metric.WithInterval(mpi.cfg.ExportInterval),
+		metric.WithProducer(runtime.NewProducer()),
+	)
+
+	mp := metric.NewMeterProvider(
+		metric.WithReader(pr),
+		metric.WithResource(mpi.r),
+	)
+	otel.SetMeterProvider(mp)
+
+	return runtime.Start(
+		runtime.WithMinimumReadMemStatsInterval(time.Second),
+	)
+}
+
+type logProviderInitializer struct {
+	cfg         config.Log
+	cc          *grpc.ClientConn
+	r           *resource.Resource
+	newExporter func(context.Context, ...otlploggrpc.Option) (*otlploggrpc.Exporter, error)
+}
+
+func (lpi logProviderInitializer) Init(ctx context.Context) error {
+	p, err := lpi.initLogProcessor(ctx)
+	if err != nil {
+		return err
+	}
+
+	lp := log.NewLoggerProvider(
+		log.WithProcessor(p),
+		log.WithResource(lpi.r),
+	)
+	global.SetLoggerProvider(lp)
+
+	log := Logger("otel")
+	otel.SetErrorHandler(otel.ErrorHandlerFunc(func(err error) {
+		log.Error("encoutered error from otel sdk", slog.Any("error", err))
+	}))
+	return nil
+}
+
+func (lpi logProviderInitializer) initLogProcessor(ctx context.Context) (log.Processor, error) {
+	// TODO: this needs to be made more specific it should either always be OTLP or STDOUT
+	//		 the enabled config is a bit confusing to interpret
+	if !lpi.cfg.Enabled {
+		exp, err := stdoutlog.New()
+		if err != nil {
+			return nil, err
+		}
+
+		sp := log.NewSimpleProcessor(exp)
+		return sp, nil
+	}
+	if lpi.cc == nil {
+		return nil, fmt.Errorf("can not enable otel logging: %w", ErrOTLPMustBeEnabled)
+	}
+
+	exp, err := lpi.newExporter(ctx, otlploggrpc.WithGRPCConn(lpi.cc))
+	if err != nil {
+		return nil, err
+	}
+
+	bsp := log.NewBatchProcessor(exp)
+	return bsp, nil
+}

config.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2025 Z5Labs and Contributors
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+package config
+
+import (
+	_ "embed"
+	"log/slog"
+	"time"
+)
+
+// Resource
+type Resource struct {
+	ServiceName    string `config:"service_name"`
+	ServiceVersion string `config:"service_version"`
+}
+
+// Trace
+type Trace struct {
+	Enabled      bool          `config:"enabled"`
+	Sampling     float64       `config:"sampling"`
+	BatchTimeout time.Duration `config:"batch_timeout"`
+}
+
+// Metric
+type Metric struct {
+	Enabled        bool          `config:"enabled"`
+	ExportInterval time.Duration `config:"export_interval"`
+}
+
+// Log
+type Log struct {
+	Enabled      bool          `config:"enabled"`
+	BatchTimeout time.Duration `config:"batch_timeout"`
+	MinLevel     slog.Level    `config:"min_level"`
+}
+
+// OTLP
+type OTLP struct {
+	Enabled bool   `config:"enabled"`
+	Target  string `config:"target"`
+}
+
+// OTel
+type OTel struct {
+	Resource Resource `config:"resource"`
+	Trace    Trace    `config:"trace"`
+	Metric   Metric   `config:"metric"`
+	Log      Log      `config:"log"`
+	OTLP     OTLP     `config:"otlp"`
+}