Instrumenting a Temporal Go application with OpenTelemetry

go get go.temporal.io/sdk@latest
go get go.temporal.io/sdk/contrib/opentelemetry@latest
go get go.temporal.io/sdk/contrib/envconfig@latest
go get go.opentelemetry.io/otel@latest
go get go.opentelemetry.io/otel/sdk@latest
go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc@latest
go get go.opentelemetry.io/otel/sdk/metric@latest
go get go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc@latest
go get go.opentelemetry.io/otel/sdk/log@latest
go get go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc@latest
go get go.opentelemetry.io/contrib/bridges/otelslog@latest

package telemetry

import (
	"context"
	"fmt"

	"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/otlptracegrpc"
	"go.opentelemetry.io/otel/log/global"
	"go.opentelemetry.io/otel/propagation"
	sdklog "go.opentelemetry.io/otel/sdk/log"
	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
)

// InitProviders initializes OTel trace, metric, and log providers.
// Call the returned shutdown function before your process exits to flush buffered telemetry.
func InitProviders(ctx context.Context) (shutdown func(context.Context) error, err error) {
	res, err := resource.New(ctx,
		resource.WithAttributes(
			semconv.ServiceName("temporal-go-app"),
		),
		resource.WithFromEnv(),
		resource.WithTelemetrySDK(),
		resource.WithProcess(),
		resource.WithHost(),
	)
	if err != nil {
		return nil, fmt.Errorf("resource: %w", err)
	}

	// Traces
	traceExp, err := otlptracegrpc.New(ctx)
	if err != nil {
		return nil, fmt.Errorf("trace exporter: %w", err)
	}
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(traceExp),
		sdktrace.WithResource(res),
	)
	otel.SetTracerProvider(tp)
	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
		propagation.TraceContext{},
		propagation.Baggage{},
	))

	// Metrics
	metricExp, err := otlpmetricgrpc.New(ctx)
	if err != nil {
		return nil, fmt.Errorf("metric exporter: %w", err)
	}
	mp := sdkmetric.NewMeterProvider(
		sdkmetric.WithReader(sdkmetric.NewPeriodicReader(metricExp)),
		sdkmetric.WithResource(res),
	)
	otel.SetMeterProvider(mp)

	// Logs
	logExp, err := otlploggrpc.New(ctx)
	if err != nil {
		return nil, fmt.Errorf("log exporter: %w", err)
	}
	lp := sdklog.NewLoggerProvider(
		sdklog.WithProcessor(sdklog.NewBatchProcessor(logExp)),
		sdklog.WithResource(res),
	)
	global.SetLoggerProvider(lp)

	shutdown = func(ctx context.Context) error {
		if err := tp.Shutdown(ctx); err != nil {
			return err
		}
		if err := mp.Shutdown(ctx); err != nil {
			return err
		}
		return lp.Shutdown(ctx)
	}
	return shutdown, nil
}

package config

import (
	"fmt"
	"os"
	"path/filepath"

	"go.temporal.io/sdk/client"
	"go.temporal.io/sdk/contrib/envconfig"
)

// CreateClientOptions returns Temporal client options.
// If TEMPORAL_PROFILE is set, it loads connection settings (address, namespace, TLS)
// from the profile in ~/.config/temporalio/temporal.toml.
// Otherwise it returns empty options, which connect to localhost:7233.
func CreateClientOptions() (client.Options, error) {
	profileName := os.Getenv("TEMPORAL_PROFILE")
	if profileName == "" {
		return client.Options{}, nil
	}

	userDir, err := os.UserConfigDir()
	if err != nil {
		return client.Options{}, fmt.Errorf("failed to get user config dir: %w", err)
	}
	configFilePath := filepath.Join(userDir, "temporalio", "temporal.toml")

	opts, err := envconfig.LoadClientOptions(envconfig.LoadClientOptionsRequest{
		ConfigFilePath:    configFilePath,
		ConfigFileProfile: profileName,
	})
	if err != nil {
		return client.Options{}, fmt.Errorf("failed to load profile %q: %w", profileName, err)
	}

	return opts, nil
}

package main

import (
	"context"
	"log"
	"log/slog"

	"go.opentelemetry.io/contrib/bridges/otelslog"
	"go.temporal.io/sdk/client"
	temporalotel "go.temporal.io/sdk/contrib/opentelemetry"
	"go.temporal.io/sdk/interceptor"
	"go.temporal.io/sdk/worker"

	"your-module/activities"
	"your-module/config"
	"your-module/telemetry"
	"your-module/workflows"
)

func main() {
	ctx := context.Background()

	shutdown, err := telemetry.InitProviders(ctx)
	if err != nil {
		log.Fatalf("failed to init OTel: %v", err)
	}
	defer shutdown(ctx)

	tracingInterceptor, err := temporalotel.NewTracingInterceptor(temporalotel.TracerOptions{})
	if err != nil {
		log.Fatalf("failed to create tracing interceptor: %v", err)
	}

	metricsHandler := temporalotel.NewMetricsHandler(temporalotel.MetricsHandlerOptions{})

	clientOpts, err := config.CreateClientOptions()
	if err != nil {
		log.Fatalf("failed to create client options: %v", err)
	}
	clientOpts.Interceptors = []interceptor.ClientInterceptor{tracingInterceptor}
	clientOpts.MetricsHandler = metricsHandler

	c, err := client.Dial(clientOpts)
	if err != nil {
		log.Fatalf("failed to create Temporal client: %v", err)
	}
	defer c.Close()

	// Route slog output to SigNoz via OTel log bridge (set after all setup so log.Fatalf above still reaches stderr)
	slog.SetDefault(slog.New(otelslog.NewHandler("temporal-worker")))

	w := worker.New(c, "my-task-queue", worker.Options{
		Interceptors: []interceptor.WorkerInterceptor{tracingInterceptor},
	})
	w.RegisterWorkflow(workflows.MyWorkflow)
	w.RegisterActivity(activities.Greet)

	if err := w.Run(worker.InterruptCh()); err != nil {
		log.Fatalf("worker exited with error: %v", err)
	}
}

package main

import (
	"context"
	"log"
	"log/slog"

	"go.opentelemetry.io/contrib/bridges/otelslog"
	"go.temporal.io/sdk/client"
	temporalotel "go.temporal.io/sdk/contrib/opentelemetry"
	"go.temporal.io/sdk/interceptor"

	"your-module/config"
	"your-module/telemetry"
	"your-module/workflows"
)

func main() {
	ctx := context.Background()

	shutdown, err := telemetry.InitProviders(ctx)
	if err != nil {
		log.Fatalf("failed to init OTel: %v", err)
	}
	defer shutdown(ctx)

	tracingInterceptor, err := temporalotel.NewTracingInterceptor(temporalotel.TracerOptions{})
	if err != nil {
		log.Fatalf("failed to create tracing interceptor: %v", err)
	}

	metricsHandler := temporalotel.NewMetricsHandler(temporalotel.MetricsHandlerOptions{})

	clientOpts, err := config.CreateClientOptions()
	if err != nil {
		log.Fatalf("failed to create client options: %v", err)
	}
	clientOpts.Interceptors = []interceptor.ClientInterceptor{tracingInterceptor}
	clientOpts.MetricsHandler = metricsHandler

	c, err := client.Dial(clientOpts)
	if err != nil {
		log.Fatalf("failed to create Temporal client: %v", err)
	}
	defer c.Close()

	// Route slog output to SigNoz via OTel log bridge (set after all setup so log.Fatalf above still reaches stderr)
	slog.SetDefault(slog.New(otelslog.NewHandler("temporal-client")))

	handle, err := c.ExecuteWorkflow(ctx, client.StartWorkflowOptions{
		ID:        "my-workflow-id",
		TaskQueue: "my-task-queue",
	}, workflows.MyWorkflow, "World")
	if err != nil {
		log.Fatalf("failed to start workflow: %v", err)
	}

	slog.Info("workflow started", "workflowID", handle.GetID(), "runID", handle.GetRunID())
}

package workflows

import (
	"time"

	"go.temporal.io/sdk/workflow"

	"your-module/activities"
)

func MyWorkflow(ctx workflow.Context, name string) (string, error) {
	ctx = workflow.WithActivityOptions(ctx, workflow.ActivityOptions{
		StartToCloseTimeout: 10 * time.Second,
	})

	var result string
	err := workflow.ExecuteActivity(ctx, activities.Greet, name).Get(ctx, &result)
	return result, err
}

package activities

import (
	"context"
	"fmt"
)

func Greet(ctx context.Context, name string) (string, error) {
	return fmt.Sprintf("Hello, %s!", name), nil
}