docs: Fix checkmarx findings for sample-app (#1761)

docs/user/integration/sample-app/main.go

@@ -43,7 +43,7 @@ var (
 )
 
 // init registers the metrics and sets up the environment
-func initMetrics() {
+func initMetrics() error {
 	var err error
 
 	hdErrorsMeter, err = meter.Int64Counter(
@@ -52,7 +52,7 @@ func initMetrics() {
 		metric.WithUnit("{device}"),
 	)
 	if err != nil {
-		panic(err)
+		return fmt.Errorf("error creating hd.errors.total counter: %w", err)
 	}
 
 	cpuEnergyMeter, err = meter.Float64Histogram(
@@ -61,7 +61,7 @@ func initMetrics() {
 		metric.WithUnit("core"),
 	)
 	if err != nil {
-		panic(err)
+		return fmt.Errorf("error creating cpu.energy.watt histogram: %w", err)
 	}
 
 	if _, err = meter.Float64ObservableGauge(
@@ -76,8 +76,9 @@ func initMetrics() {
 			return nil
 		}),
 	); err != nil {
-		panic(err)
+		return fmt.Errorf("error creating cpu.temperature.celsius gauge: %w", err)
 	}
+	return nil
 }
 
 func initTerminateEndpoint() {
@@ -162,7 +163,7 @@ func terminateHandler(w http.ResponseWriter, r *http.Request) {
 
 	// Terminate the request randomly with a success or error response
 	if randBool() {
-		span.RecordError(fmt.Errorf("Random logic decided to fail the request"))
+		span.RecordError(fmt.Errorf("random logic decided to fail the request"))
 		span.SetStatus(codes.Error, "error")
 
 		hdErrorsMeter.Add(ctx, 5, metric.WithAttributes(hdErrorsAttributeSda))
@@ -180,13 +181,26 @@ func terminateHandler(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintf(w, "Success")
 }
 
-func main() {
+func run() error {
 	ctx := context.Background()
 
 	// Instantiate the trace and metric providers
-	res := newOtelResource()
-	tp := newTraceProvider(newTraceExporter(ctx), res)
-	mp := newMeterProvider(newMetricReader(ctx), res)
+	res, err := newOtelResource()
+	if err != nil {
+		return fmt.Errorf("creating resource: %w", err)
+	}
+
+	te, err := newTraceExporter(ctx)
+	if err != nil {
+		return fmt.Errorf("creating trace exporter: %w", err)
+	}
+	tp := newTraceProvider(te, res)
+
+	mr, err := newMetricReader(ctx)
+	if err != nil {
+		return fmt.Errorf("creating meter provider: %w", err)
+	}
+	mp := newMeterProvider(mr, res)
 
 	// Handle shutdown properly so nothing leaks.
 	defer func() {
@@ -223,8 +237,16 @@ func main() {
 
 	//Start the HTTP server
 	logger.Info("Starting server on port " + strconv.Itoa(serverPort))
-	err := http.ListenAndServe(fmt.Sprintf(":%d", serverPort), nil)
+	err = http.ListenAndServe(fmt.Sprintf(":%d", serverPort), nil)
 	if err != nil {
-		panic(err)
+		return fmt.Errorf("error starting server: %w", err)
+	}
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		logger.Error("Error running server", slog.String("error", err.Error()))
+		os.Exit(1)
 	}
 }

docs/user/integration/sample-app/setup.go

@@ -17,7 +17,7 @@ import (
 	semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
 )
 
-func newOtelResource() *resource.Resource {
+func newOtelResource() (*resource.Resource, error) {
 	// Ensure default SDK resources and the required service name are set.
 	res, err := resource.New(
 		context.Background(),
@@ -28,9 +28,9 @@ func newOtelResource() *resource.Resource {
 	)
 
 	if err != nil {
-		panic(fmt.Errorf("creating resource: %w", err))
+		return nil, fmt.Errorf("creating resource: %w", err)
 	}
-	return res
+	return res, nil
 }
 
 func newTraceProvider(exp trace.SpanExporter, res *resource.Resource) *trace.TracerProvider {
@@ -40,24 +40,24 @@ func newTraceProvider(exp trace.SpanExporter, res *resource.Resource) *trace.Tra
 	)
 }
 
-func newTraceExporter(ctx context.Context) trace.SpanExporter {
+func newTraceExporter(ctx context.Context) (trace.SpanExporter, error) {
 	var exporterEnv = os.Getenv("OTEL_TRACES_EXPORTER")
 	var endpointEnv = os.Getenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT")
 
 	if exporterEnv == "otlp" || endpointEnv != "" {
 		exporter, err := otlptracegrpc.New(ctx)
 		if err != nil {
-			panic(fmt.Errorf("creating OTLP trace exporter: %w", err))
+			return nil, fmt.Errorf("creating OTLP trace exporter: %w", err)
 		}
 		logger.Info("using OTLP trace exporter with endpoint: " + exporterEnv)
-		return exporter
+		return exporter, nil
 	}
 	exporter, err := stdouttrace.New()
 	if err != nil {
-		panic(fmt.Errorf("creating stdout trace exporter: %w", err))
+		return nil, fmt.Errorf("creating stdout trace exporter: %w", err)
 	}
 	logger.Info("using console trace exporter")
-	return exporter
+	return exporter, nil
 }
 
 func newMeterProvider(exp metric.Reader, res *resource.Resource) *metric.MeterProvider {
@@ -69,33 +69,33 @@ func newMeterProvider(exp metric.Reader, res *resource.Resource) *metric.MeterPr
 	return meterProvider
 }
 
-func newMetricReader(ctx context.Context) metric.Reader {
+func newMetricReader(ctx context.Context) (metric.Reader, error) {
 	var exporterEnv = os.Getenv("OTEL_METRICS_EXPORTER")
 	var endpointEnv = os.Getenv("OTEL_EXPORTER_OTLP_METRICS_ENDPOINT")
 
 	if exporterEnv == "prometheus" {
 		reader, err := prometheus.New()
 		if err != nil {
-			panic(fmt.Errorf("creating prometheus metric reader: %w", err))
+			return nil, fmt.Errorf("creating prometheus metric reader: %w", err)
 		}
 		logger.Info("Using Prometheus metric exporter")
-		return reader
+		return reader, nil
 	}
 
 	if exporterEnv == "otlp" || endpointEnv != "" {
 		exporter, err := otlpmetricgrpc.New(ctx)
 		if err != nil {
-			panic(fmt.Errorf("creating OTLP metric exporter: %w", err))
+			return nil, fmt.Errorf("creating OTLP metric exporter: %w", err)
 		}
 		logger.Info("using OTLP metric exporter with endpoint: " + endpointEnv)
-		return metric.NewPeriodicReader(exporter, metric.WithInterval(10*time.Second))
+		return metric.NewPeriodicReader(exporter, metric.WithInterval(10*time.Second)), nil
 	}
 	exporter, err := stdoutmetric.New()
 	if err != nil {
-		panic(fmt.Errorf("creating stdout metric exporter: %w", err))
+		return nil, fmt.Errorf("creating stdout metric exporter: %w", err)
 	}
 	logger.Info("using console metric exporter")
 	return metric.NewPeriodicReader(exporter,
 		// Default is 1m. Set to 10s for demonstrative purposes.
-		metric.WithInterval(5*time.Second))
+		metric.WithInterval(5*time.Second)), nil
 }