Tracing med OpenTelemetry

package main

import (
	"context"
	"log"
	"os"
	"time"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
	"go.opentelemetry.io/otel/trace"
)

// initTracerProvider initializes an OpenTelemetry TracerProvider
// with a stdout exporter for demonstration.
func initTracerProvider() *sdktrace.TracerProvider {
	// Create stdout exporter to print traces to the console
	exporter, err := stdouttrace.New(stdouttrace.WithPrettyPrint())
	if err != nil {
		log.Fatalf("failed to create stdout exporter: %v", err)
	}

	// Create a new TracerProvider with the exporter and a service name
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(exporter), // Batch spans for efficiency
		sdktrace.WithResource(resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceName("my-simple-service"),
			attribute.String("environment", "development"),
		)),
	)
	otel.SetTracerProvider(tp) // Set the global TracerProvider

	return tp
}

func main() {
	tp := initTracerProvider()
	defer func() {
		if err := tp.Shutdown(context.Background()); err != nil {
			log.Fatalf("Error shutting down tracer provider: %v", err)
		}
	}()

	// Get a tracer
	tracer := otel.Tracer("my-app-tracer")

	// Create a root span
	ctx, span := tracer.Start(context.Background(), "main-operation")
	defer span.End()

	log.Println("Hello from main-operation with tracing enabled!")
	time.Sleep(100 * time.Millisecond) // Simulate some work

	// Create a child span
	_, childSpan := tracer.Start(ctx, "sub-operation")
	defer childSpan.End()
	childSpan.SetAttributes(attribute.String("task", "processing"))
	log.Println("Doing some sub-operation...")
	time.Sleep(50 * time.Millisecond) // Simulate more work

	log.Println("Trace data will be printed on shutdown.")
}

package main

import (
	"context"
	"log"
	"net"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	// OpenTelemetry imports
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.24.0"

	// gRPC OpenTelemetry instrumentation
	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"

	// For this example, we'll define a simple service in-line
	pb "google.golang.org/grpc/examples/helloworld/helloworld" // Using a standard example proto
)

// initTracerProvider initializes an OpenTelemetry TracerProvider
// with a stdout exporter for demonstration.
func initTracerProvider() *sdktrace.TracerProvider {
	exporter, err := stdouttrace.New(stdouttrace.WithPrettyPrint())
	if err != nil {
		log.Fatalf("failed to create stdout exporter: %v", err)
	}

	tp := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(exporter),
		sdktrace.WithResource(resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceName("grpc-otel-demo"),
			attribute.String("environment", "development"),
		)),
	)
	otel.SetTracerProvider(tp)
	return tp
}

// helloServer is a simple gRPC server for demonstration
type helloServer struct {
	pb.UnimplementedGreeterServer
}

func (s *helloServer) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	log.Printf("Received: %v", in.GetName())
	// Simulate some work
	time.Sleep(50 * time.Millisecond)
	return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
	// 1. Initialize OpenTelemetry TracerProvider
	tp := initTracerProvider()
	defer func() {
		if err := tp.Shutdown(context.Background()); err != nil {
			log.Fatalf("Error shutting down tracer provider: %v", err)
		}
	}()

	// 2. Start gRPC Server with OpenTelemetry Interceptor
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer(
		grpc.UnaryInterceptor(otelgrpc.UnaryServerInterceptor()), // Apply OTel server interceptor
	)
	pb.RegisterGreeterServer(s, &helloServer{})
	log.Println("Server listening on :50051")
	go func() {
		if err := s.Serve(lis); err != nil {
			log.Fatalf("failed to serve: %v", err)
		}
	}()
	defer s.Stop()

	// Allow server to start
	time.Sleep(1 * time.Second)

	// 3. Create gRPC Client with OpenTelemetry Interceptor
	conn, err := grpc.Dial(
		"localhost:50051",
		grpc.WithInsecure(), // For simplicity, use insecure
		grpc.WithBlock(),
		grpc.WithUnaryInterceptor(otelgrpc.UnaryClientInterceptor()), // Apply OTel client interceptor
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	c := pb.NewGreeterClient(conn)

	// 4. Make a gRPC call
	log.Println("Making gRPC call...")
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	r, err := c.SayHello(ctx, &pb.HelloRequest{Name: "CoddyKit User"})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", r.GetMessage())

	// Give some time for spans to be processed and exported
	time.Sleep(1 * time.Second)
	log.Println("Trace data should now be visible in console.")
}

package main

import (
	"context"
	"log"
	"time"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
	"go.opentelemetry.io/otel/trace"
)

// initTracerProvider initializes an OpenTelemetry TracerProvider
func initTracerProvider() *sdktrace.TracerProvider {
	exporter, err := stdouttrace.New(stdouttrace.WithPrettyPrint())
	if err != nil {
		log.Fatalf("failed to create stdout exporter: %v", err)
	}
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(exporter),
		sdktrace.WithResource(resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceName("custom-attributes-demo"),
		)),
	)
	otel.SetTracerProvider(tp)
	return tp
}

func main() {
	tp := initTracerProvider()
	defer func() {
		if err := tp.Shutdown(context.Background()); err != nil {
			log.Fatalf("Error shutting down tracer provider: %v", err)
		}
	}()

	tracer := otel.Tracer("my-custom-tracer")

	// Start a root span
	ctx, span := tracer.Start(context.Background(), "process-order")
	defer span.End()

	// Add custom attributes to the root span
	span.SetAttributes(
		attribute.String("user.id", "user123"),
		attribute.Int("order.id", 45678),
		attribute.Bool("is_premium_user", true),
	)
	log.Println("Processing order with custom attributes...")
	time.Sleep(100 * time.Millisecond)

	// Create a child span
	_, childSpan := tracer.Start(ctx, "database-query")
	defer childSpan.End()
	childSpan.SetAttributes(
		attribute.String("db.system", "postgres"),
		attribute.String("db.statement", "SELECT * FROM orders WHERE id=45678"),
	)
	log.Println("Executing database query...")
	time.Sleep(50 * time.Millisecond)

	log.Println("Check the console output for custom attributes in the spans!")
	time.Sleep(500 * time.Millisecond) // Ensure spans are exported
}