Merge pull request #162 from intelops/refactoring-otel

refactoring: added opentel config for rest in a separate file

Author: mahendraintelops

charts/compage/templates/configmaps/core.yaml

@@ -0,0 +1,8 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: core-open-telemetry-data
+  labels:
+    {{- include "compage.core.labels" . | nindent 4 }}
+data:
+  OTEL_EXPORTER_OTLP_ENDPOINT: {{.Values.core.open-telemetry.otelExporterOtlpEndpoint}}

charts/compage/templates/deployments/core.yaml

@@ -42,6 +42,16 @@ spec:
               port: grpc
             initialDelaySeconds: 15
             periodSeconds: 30
+          env:
+            - name: SERVICE_NAME
+              value: Core
+            - name: INSECURE_MODE
+              value: "true"
+            - name: OTEL_EXPORTER_OTLP_ENDPOINT
+              valueFrom:
+                configMapKeyRef:
+                  name: core-open-telemetry-data
+                  key: OTEL_EXPORTER_OTLP_ENDPOINT
           resources:
             {{- toYaml .Values.core.resources | nindent 12 }}
       {{- with .Values.core.nodeSelector }}

charts/compage/values.yaml

@@ -87,6 +87,9 @@ core:
     type: ClusterIP
     port: 50051
 
+  open-telemetry:
+    otelExporterOtlpEndpoint: "http://localhost:4317"
+
   resources:
     limits:
       cpu: 100m

core/config/grpc-opentel-config.go

@@ -0,0 +1,59 @@
+package config
+
+import (
+	"context"
+	log "github.com/sirupsen/logrus"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/sdk/resource"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	"google.golang.org/grpc/credentials"
+	"os"
+)
+
+// InitGrpcTracer configures an OpenTelemetry exporter and trace provider
+func InitGrpcTracer(serviceName, collectorURL, insecure string) *sdktrace.TracerProvider {
+	secureOption := otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
+	if len(insecure) > 0 {
+		secureOption = otlptracegrpc.WithInsecure()
+	}
+
+	exporter, err := otlptrace.New(
+		context.Background(),
+		otlptracegrpc.NewClient(
+			secureOption,
+			otlptracegrpc.WithEndpoint(collectorURL),
+		),
+	)
+
+	if err != nil {
+		log.Debugf("error while configuring opentel, %v", err)
+		os.Exit(1)
+	}
+
+	resources, err := resource.New(
+		context.Background(),
+		resource.WithAttributes(
+			attribute.String("service.name", serviceName),
+			attribute.String("library.language", "go"),
+		),
+	)
+	if err != nil {
+		log.Errorf("Could not set resources: %v", err)
+		os.Exit(1)
+	}
+
+	traceProvider := sdktrace.NewTracerProvider(
+		sdktrace.WithSampler(sdktrace.AlwaysSample()),
+		sdktrace.WithBatcher(exporter),
+		sdktrace.WithResource(resources),
+	)
+
+	otel.SetTracerProvider(traceProvider)
+	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
+
+	return traceProvider
+}

core/go.mod

@@ -6,15 +6,27 @@ require (
 	github.com/gertd/go-pluralize v0.2.1
 	github.com/iancoleman/strcase v0.2.0
 	github.com/sirupsen/logrus v1.9.0
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.42.0
+	go.opentelemetry.io/otel v1.16.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.16.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.16.0
+	go.opentelemetry.io/otel/sdk v1.16.0
 	golang.org/x/exp v0.0.0-20230321023759-10a507213a29
 	golang.org/x/text v0.9.0
 	google.golang.org/grpc v1.56.0
 	google.golang.org/protobuf v1.31.0
 )
 
 require (
+	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
+	github.com/go-logr/logr v1.2.4 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/stretchr/testify v1.8.3 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.16.0 // indirect
+	go.opentelemetry.io/otel/metric v1.16.0 // indirect
+	go.opentelemetry.io/otel/trace v1.16.0 // indirect
+	go.opentelemetry.io/proto/otlp v0.19.0 // indirect
 	golang.org/x/net v0.10.0 // indirect
 	golang.org/x/sys v0.8.0 // indirect
 	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect

core/go.sum

@@ -21,6 +21,7 @@ import (
 
 const RestServerPath = "/pkg/rest/server"
 const RestClientPath = "/pkg/rest/client"
+const ConfigPath = "/config"
 
 const ControllersPath = RestServerPath + "/controllers"
 const ServicesPath = RestServerPath + "/services"
@@ -53,6 +54,7 @@ const MySQLGORMDBConfigFile = "mysql-gorm.go.tmpl"
 const SQLiteGORMDBConfigFile = "sqlite-gorm.go.tmpl"
 
 const ClientFile = "client.go.tmpl"
+const ConfigFile = "rest-opentel-config.go.tmpl"
 
 // MongoDB nosql databases
 const MongoDB = "MongoDB"
@@ -155,10 +157,15 @@ func (c *Copier) createRestClientDirectories() error {
 
 // createRestServerDirectories creates rest server directories.
 func (c *Copier) createRestServerDirectories() error {
+	configDirectory := c.NodeDirectoryName + ConfigPath
 	controllersDirectory := c.NodeDirectoryName + ControllersPath
 	modelsDirectory := c.NodeDirectoryName + ModelsPath
 	servicesDirectory := c.NodeDirectoryName + ServicesPath
 	daosDirectory := c.NodeDirectoryName + DaosPath
+	if err := utils.CreateDirectories(configDirectory); err != nil {
+		log.Debugf("error creating config directory: %v", err)
+		return err
+	}
 	if err := utils.CreateDirectories(controllersDirectory); err != nil {
 		log.Debugf("error creating controllers directory: %v", err)
 		return err
@@ -624,6 +631,22 @@ func (c *Copier) CreateRestServer() error {
 				return err
 			}
 		}
+		// copy opentel config file
+		var filePaths []string
+		// client files
+		targetOpenTelConfigFileName := c.NodeDirectoryName + ConfigPath + "/" + ConfigFile
+		_, err := utils.CopyFile(targetOpenTelConfigFileName, c.TemplatesRootPath+ConfigPath+"/"+ConfigFile)
+		if err != nil {
+			log.Debugf("error copying opentel config file: %v", err)
+			return err
+		}
+		filePaths = append(filePaths, targetOpenTelConfigFileName)
+		err = executor.Execute(filePaths, c.Data)
+		if err != nil {
+			log.Debugf("error executing opentel config file: %v", err)
+			return err
+		}
+
 		if c.IsSQLDB {
 			// create sql db config file (common to all resources for specific database)
 			// No vars in config file as of now but in future they may be there.

core/internal/languages/golang/frameworks/go-gin-server/copier.go

@@ -54,7 +54,7 @@ const MySQLGORMDBConfigFile = "mysql-gorm.go.tmpl"
 const SQLiteGORMDBConfigFile = "sqlite-gorm.go.tmpl"
 
 const ClientFile = "client.go.tmpl"
-const ConfigFile = "opentel-config.go.tmpl"
+const ConfigFile = "grpc-opentel-config.go.tmpl"
 
 // MongoDB nosql databases
 const MongoDB = "MongoDB"
@@ -165,21 +165,27 @@ func (c *Copier) createGrpcServerDirectories() error {
 	servicesDirectory := c.NodeDirectoryName + ServicesPath
 	daosDirectory := c.NodeDirectoryName + DaosPath
 	if err := utils.CreateDirectories(configDirectory); err != nil {
+		log.Debugf("error creating config directory: %v", err)
 		return err
 	}
 	if err := utils.CreateDirectories(apiDirectory); err != nil {
+		log.Debugf("error creating api directory: %v", err)
 		return err
 	}
 	if err := utils.CreateDirectories(controllersDirectory); err != nil {
+		log.Debugf("error creating controllers directory: %v", err)
 		return err
 	}
 	if err := utils.CreateDirectories(modelsDirectory); err != nil {
+		log.Debugf("error creating models directory: %v", err)
 		return err
 	}
 	if err := utils.CreateDirectories(servicesDirectory); err != nil {
+		log.Debugf("error creating services directory: %v", err)
 		return err
 	}
 	if err := utils.CreateDirectories(daosDirectory); err != nil {
+		log.Debugf("error creating daos directory: %v", err)
 		return err
 	}
 	if c.IsSQLDB {

core/internal/languages/golang/frameworks/go-grpc-server/copier.go

@@ -131,7 +131,7 @@ func GetDefaultValueForDataType(value string) interface{} {
 	} else if value == "bool" {
 		return true
 	} else if value == "float32" ||
-		value == "float64 " ||
+		value == "float64" ||
 		value == "complex64" ||
 		value == "complex128" {
 		return 1.0

core/internal/languages/utils/common.go

@@ -1,19 +1,45 @@
 package main
 
 import (
+	"context"
 	server "github.com/intelops/compage/core/cmd/grpc"
+	"github.com/intelops/compage/core/config"
 	project "github.com/intelops/compage/core/gen/api/v1"
 	log "github.com/sirupsen/logrus"
+	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 	"golang.org/x/exp/slices"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/reflection"
+
 	"net"
 	"os"
 	"os/signal"
 	"syscall"
 )
 
+var (
+	serviceName  = os.Getenv("SERVICE_NAME")
+	collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+	insecure     = os.Getenv("INSECURE_MODE")
+)
+
 func main() {
+	// grpc server configuration
+	// Initialize the exporter
+	var grpcTraceProvider *sdktrace.TracerProvider
+	if len(serviceName) > 0 && len(collectorURL) > 0 {
+		// add opentel
+		grpcTraceProvider = config.InitGrpcTracer(serviceName, collectorURL, insecure)
+	}
+	defer func() {
+		if grpcTraceProvider != nil {
+			if err := grpcTraceProvider.Shutdown(context.Background()); err != nil {
+				log.Printf("Error shutting down tracer provider: %v", err)
+			}
+		}
+	}()
+
 	// check if the git submodules have been pulled (mainly need to check this on developer's machine)
 	if checkIfGitSubmodulesExist() {
 		log.Println("starting gRPC server...")
@@ -56,9 +82,9 @@ func startGrpcServer() {
 	if err != nil {
 		log.Fatalf("failed to serve: %v", err)
 	}
-	var opts []grpc.ServerOption
 
-	grpcServer := grpc.NewServer(opts...)
+	grpcServer := grpc.NewServer(grpc.UnaryInterceptor(otelgrpc.UnaryServerInterceptor()),
+		grpc.StreamInterceptor(otelgrpc.StreamServerInterceptor()))
 	impl := server.New()
 	project.RegisterProjectServiceServer(grpcServer, impl)
 	reflection.Register(grpcServer)