feat: add jaeger

cmd/layotto/main.go

@@ -170,6 +170,7 @@ import (
 	_ "mosn.io/layotto/pkg/wasm"
 
 	_ "mosn.io/layotto/diagnostics/exporter_iml"
+	"mosn.io/layotto/diagnostics/jaeger"
 	lprotocol "mosn.io/layotto/diagnostics/protocol"
 	lsky "mosn.io/layotto/diagnostics/skywalking"
 )
@@ -515,7 +516,7 @@ func ExtensionsRegister(_ *cli.Context) {
 	trace.RegisterTracerBuilder("SOFATracer", protocol.HTTP1, tracehttp.NewTracer)
 	trace.RegisterTracerBuilder("SOFATracer", lprotocol.Layotto, diagnostics.NewTracer)
 	trace.RegisterTracerBuilder(skywalking.SkyDriverName, lprotocol.Layotto, lsky.NewGrpcSkyTracer)
-
+	trace.RegisterTracerBuilder("Jaeger", lprotocol.Layotto, jaeger.NewGrpcJaegerTracer)
 }
 
 func main() {

cmd/layotto_multiple_api/main.go

@@ -163,6 +163,7 @@ import (
 	"mosn.io/layotto/pkg/runtime"
 
 	_ "mosn.io/layotto/diagnostics/exporter_iml"
+	"mosn.io/layotto/diagnostics/jaeger"
 	lprotocol "mosn.io/layotto/diagnostics/protocol"
 	lsky "mosn.io/layotto/diagnostics/skywalking"
 )
@@ -489,6 +490,7 @@ func ExtensionsRegister(_ *cli.Context) {
 	trace.RegisterTracerBuilder("SOFATracer", protocol.HTTP1, tracehttp.NewTracer)
 	trace.RegisterTracerBuilder("SOFATracer", "layotto", diagnostics.NewTracer)
 	trace.RegisterTracerBuilder(skywalking.SkyDriverName, lprotocol.Layotto, lsky.NewGrpcSkyTracer)
+	trace.RegisterTracerBuilder("Jaeger", lprotocol.Layotto, jaeger.NewGrpcJaegerTracer)
 
 }
 

configs/config_trace_jaeger.json

@@ -0,0 +1,82 @@
+{
+  "servers": [
+    {
+      "default_log_path": "stdout",
+      "default_log_level": "INFO",
+      "listeners": [
+        {
+          "name": "grpc",
+          "address": "0.0.0.0:34904",
+          "bind_port": true,
+          "filter_chains": [
+            {
+              "filters": [
+                {
+                  "type": "grpc",
+                  "config": {
+                    "server_name": "runtime",
+                    "grpc_config": {
+                      "hellos": {
+                        "helloworld": {
+                          "hello": "greeting"
+                        }
+                      },
+                      "config_store": {
+                        "etcd": {
+                          "address": [
+                            "127.0.0.1:2379"
+                          ],
+                          "timeout": "10"
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ],
+          "stream_filters": [
+            {
+              "type": "flowControlFilter",
+              "config": {
+                "global_switch": true,
+                "limit_key_type": "PATH",
+                "rules": [
+                  {
+                    "resource": "/spec.proto.runtime.v1.Runtime/SayHello",
+                    "grade": 1,
+                    "threshold": 5
+                  }
+                ]
+              }
+            },
+            {
+              "type": "grpc"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "tracing": {
+    "enable": true,
+    "driver": "jaeger",
+    "config": {
+      "config": {
+        "service_name": "layotto",
+        "agent_host": "127.0.0.1:6831",
+        "strategy": "collector"
+      }
+    }
+  },
+  "metrics": {
+    "sinks": [
+      {
+        "type": "prometheus",
+        "config": {
+          "port": 34903
+        }
+      }
+    ]
+  }
+}

diagnostics/jaeger/grpc_tracer.go

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2021 Layotto Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jaeger
+
+import (
+	"context"
+	"os"
+	"time"
+
+	"github.com/opentracing/opentracing-go"
+	jaegerc "github.com/uber/jaeger-client-go"
+	"github.com/uber/jaeger-client-go/config"
+	"mosn.io/api"
+	"mosn.io/mosn/pkg/log"
+	"mosn.io/mosn/pkg/trace"
+	"mosn.io/mosn/pkg/trace/jaeger"
+	"mosn.io/mosn/pkg/types"
+
+	ltrace "mosn.io/layotto/components/trace"
+	"mosn.io/layotto/diagnostics/grpc"
+	"mosn.io/layotto/diagnostics/protocol"
+)
+
+const (
+	serviceName              = "layotto"
+	strategy                 = "strategy"
+	agentHost                = "agent_host"
+	collectorEndpoint        = "collector_endpoint"
+	defaultServiceName       = "layotto"
+	defaultJaegerAgentHost   = "127.0.0.1:6831"
+	jaegerAgentHostKey       = "TRACE"
+	appIDKey                 = "APP_ID"
+	defaultCollectorEndpoint = "http://127.0.0.1:14268/api/traces"
+	defaultStrategy          = "collector"
+)
+
+type grpcJaegerTracer struct {
+	tracer opentracing.Tracer
+}
+
+type grpcJaegerSpan struct {
+	*ltrace.Span
+	ctx        context.Context
+	trace      *grpcJaegerTracer
+	jaegerSpan opentracing.Span
+	spanCtx    jaegerc.SpanContext
+}
+
+func init() {
+	trace.RegisterTracerBuilder(jaeger.DriverName, protocol.Layotto, NewGrpcJaegerTracer)
+}
+
+func NewGrpcJaegerTracer(traceCfg map[string]interface{}) (api.Tracer, error) {
+	var reporter *config.ReporterConfig
+
+	// Determining whether to start the agent
+	strategy := getStrategy(traceCfg)
+
+	if strategy == defaultStrategy {
+		reporter = &config.ReporterConfig{
+			LogSpans:            false,
+			BufferFlushInterval: 1 * time.Second,
+			CollectorEndpoint:   getCollectorEndpoint(traceCfg),
+		}
+	} else {
+		reporter = &config.ReporterConfig{
+			LogSpans:            false,
+			BufferFlushInterval: 1 * time.Second,
+			LocalAgentHostPort:  getAgentHost(traceCfg),
+		}
+	}
+
+	cfg := config.Configuration{
+		Disabled: false,
+		Sampler: &config.SamplerConfig{
+			Type:  "const",
+			Param: 1,
+		},
+		Reporter: reporter,
+	}
+
+	cfg.ServiceName = getServiceName(traceCfg)
+	tracer, _, err := cfg.NewTracer()
+
+	log.DefaultLogger.Infof("[layotto] [jaeger] [tracer] jaeger agent host:%s, report service name:%s",
+		getAgentHost(traceCfg), getServiceName(traceCfg))
+
+	if err != nil {
+		log.DefaultLogger.Errorf("[jaeger] [tracer] [layotto] cannot initialize Jaeger Tracer")
+		return nil, err
+	}
+
+	return &grpcJaegerTracer{
+		tracer: tracer,
+	}, nil
+}
+
+func getAgentHost(traceCfg map[string]interface{}) string {
+	if agentHost, ok := traceCfg[agentHost]; ok {
+		return agentHost.(string)
+	}
+
+	//if TRACE is not set, get it from the env variable
+	if host := os.Getenv(jaegerAgentHostKey); host != "" {
+		return host
+	}
+
+	return defaultJaegerAgentHost
+}
+
+func getStrategy(traceCfg map[string]interface{}) string {
+	if strategy, ok := traceCfg[strategy]; ok {
+		return strategy.(string)
+	}
+
+	return defaultStrategy
+}
+
+func getCollectorEndpoint(traceCfg map[string]interface{}) string {
+	if collectorEndpoint, ok := traceCfg[collectorEndpoint]; ok {
+		return collectorEndpoint.(string)
+	}
+
+	return defaultCollectorEndpoint
+}
+
+func getServiceName(traceCfg map[string]interface{}) string {
+	if service, ok := traceCfg[serviceName]; ok {
+		return service.(string)
+	}
+
+	//if service_name is not set, get it from the env variable
+	if appID := os.Getenv(appIDKey); appID != "" {
+		return appID + "_sidecar"
+	}
+
+	return defaultServiceName
+}
+
+func (t *grpcJaegerTracer) Start(ctx context.Context, request interface{}, startTime time.Time) api.Span {
+	header, ok := request.(*grpc.RequestInfo)
+	if !ok {
+		log.DefaultLogger.Debugf("[jaeger] [tracer] [layotto] unable to get request header, downstream trace ignored")
+		return &jaeger.Span{}
+	}
+
+	//create entry span (downstream)
+	sp, _ := opentracing.StartSpanFromContextWithTracer(ctx, t.tracer, header.FullMethod)
+
+	//renew span context
+	newSpanCtx, _ := sp.Context().(jaegerc.SpanContext)
+
+	return &grpcJaegerSpan{
+		trace:      t,
+		ctx:        ctx,
+		Span:       &ltrace.Span{},
+		spanCtx:    newSpanCtx,
+		jaegerSpan: sp,
+	}
+}
+
+func (s *grpcJaegerSpan) TraceId() string {
+	return s.spanCtx.TraceID().String()
+}
+
+func (s *grpcJaegerSpan) InjectContext(requestHeaders types.HeaderMap, requestInfo api.RequestInfo) {
+}
+
+func (s *grpcJaegerSpan) SetRequestInfo(requestInfo api.RequestInfo) {
+}
+
+func (s *grpcJaegerSpan) FinishSpan() {
+	s.jaegerSpan.Finish()
+}

diagnostics/jaeger/jaeger-docker-compose.yaml

@@ -0,0 +1,29 @@
+#Licensed to the Apache Software Foundation (ASF) under one or more
+#contributor license agreements.  See the NOTICE file distributed with
+#this work for additional information regarding copyright ownership.
+#The ASF licenses this file to You under the Apache License, Version 2.0
+#(the "License"); you may not use this file except in compliance with
+#the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+version: '3.3'
+services:
+  jaegertracing-all-in-one:
+    image: jaegertracing/all-in-one:latest
+    ports:
+      - "5775:5775/udp"
+      - "16686:16686"
+      - "14250:14250"
+      - "14268:14268"
+      - "6831:6831"
+
+
+
+