OpenTelemetry Go Installation

import (
  "context"
  "os"
  "os/exec"
  "strings"
 
  "go.opentelemetry.io/otel"
  "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
  "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
  "go.opentelemetry.io/otel/sdk/trace"
)
 
func initOpenTelemetry() func(context.Context) error {
	// Replace these values with your AppSignal application name, environment
	// and push API key. These are used by the resource attributes configuration below.
	name := "My app"
	push_api_key := "0000-0000-0000-0000"
	environment := "development"
 
	// Set the name of the service that is being monitored. A common choice is the
	// name of the framework used. This is used to group traces and metrics in AppSignal.
	service_name := "My service name"
 
	// Replace `http://localhost:8099` with the address of your AppSignal collector
	// if it's running on another host.
	endpoint := "localhost:8099"
 
	hostname, err := os.Hostname()
	if err != nil {
		hostname = "unknown"
	}
 
	cmd := exec.Command("git", "rev-parse", "--short", "HEAD")
	output, err := cmd.Output()
	if err != nil {
		revision = "unknown"
	} else {
        revision = strings.TrimSpace(string(output))
    }
 
	resource := resource.NewSchemaless(
		attribute.String("appsignal.config.name", name),
		attribute.String("appsignal.config.environment", environment),
		attribute.String("appsignal.config.push_api_key", push_api_key),
		attribute.String("appsignal.config.revision", revision),
		attribute.String("appsignal.config.language_integration", "golang"),
		attribute.String("appsignal.config.app_path", os.Getenv("PWD")),
		attribute.String("service.name", service_name),
		attribute.String("host.name", hostname),
	)
 
	// Tracing
	traceClient := otlptracehttp.NewClient(
		otlptracehttp.WithInsecure(),
		otlptracehttp.WithEndpoint(endpoint),
	)
 
	traceExporter, err := otlptrace.New(context.Background(), traceClient)
	if err != nil {
		log.Fatal("Error creating OTLP trace exporter: %w")
	}
 
	tracerProvider := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(traceExporter),
		sdktrace.WithResource(resource),
	)
 
	otel.SetTracerProvider(tracerProvider)
	otel.SetTextMapPropagator(
        propagation.NewCompositeTextMapPropagator(
            propagation.TraceContext{},
            propagation.Baggage{}
        )
    )
 
 
	// Metrics
	metricExporter, err := otlpmetrichttp.New(
		context.Background(),
		otlpmetrichttp.WithInsecure(),
		otlpmetrichttp.WithEndpoint(endpoint),
	)
	if err != nil {
		log.Fatal("creating OTLP metric exporter: %w")
	}
 
	meterProvider := sdkmetric.NewMeterProvider(
		sdkmetric.WithReader(sdkmetric.NewPeriodicReader(metricExporter)),
		sdkmetric.WithResource(res),
	)
	otel.SetMeterProvider(meterProvider)
 
	// Logs
	logExporter, err := otlploghttp.New(
		context.Background(),
		otlploghttp.WithInsecure(),
		otlploghttp.WithEndpoint(endpoint),
	)
	if err != nil {
		log.Fatal("creating OTLP log exporter: %w")
	}
 
	loggerProvider := sdklog.NewLoggerProvider(
		sdklog.WithResource(res),
		sdklog.WithProcessor(
			sdklog.NewBatchProcessor(logExporter),
		),
	)
	global.SetLoggerProvider(loggerProvider)
 
	// Cleanup
	return func() {
		if err := tracerProvider.Shutdown(context.Background()); err != nil {
			log.Println("Error shutting down tracer provider:", err)
		}
		if err := meterProvider.Shutdown(context.Background()); err != nil {
			log.Println("Error shutting down meter provider:", err)
		}
		if err := loggerProvider.Shutdown(context.Background()); err != nil {
			log.Println("Error shutting down logger provider:", err)
		}
	}
}
 
func main() {
	cleanup := initOpenTelemetry()
	defer cleanup()
 
	// ... your application's initialization code
}