tencent cloud

All product documents
Tencent Cloud Observability Platform
DocumentationTencent Cloud Observability Platform
Reporting with gRPC-Jaeger Interceptor
Last updated: 2024-11-01 17:55:45
Reporting with gRPC-Jaeger Interceptor
Last updated: 2024-11-01 17:55:45
This document describes how to report the data of a Go application with the gRPC-Jaeger interceptor.

Directions

Step 1. Get the endpoint and token

Log in to the APM console, enter the Application monitoring > Application list page, click Access application, and select the Go language and the gRPC-Jaeger data collection method. Then, get the endpoint and token in the step of access method selection.



Step 2. Install the Jaeger agent

1. Download the Jaeger agent.
2. Run the following command to start the agent:
nohup ./jaeger-agent --reporter.grpc.host-port={{collectorRPCHostPort}} --agent.tags=token={{token}}

Step 3. Select the reporting type to report application data

Select the reporting type to report the data of a Go application through the gRPC-Jaeger interceptor:

Server

1. Import the instrumentation dependency opentracing-contrib/go-grpc on the server.
Dependency path: github.com/opentracing-contrib/go-grpc
Version requirement: ≥ v0.0.0-20210225150812-73cb765af46e
2. Configure Jaeger and create a trace object. Below is a sample:
cfg := &jaegerConfig.Configuration{
    ServiceName: grpcServerName, // Call trace of the target service. Enter the service name.
    Sampler: &jaegerConfig.SamplerConfig{ // Sampling policy configuration. See section 4.1.1 for details.
    Type:  "const",
    Param: 1,
    },
    Reporter: &jaegerConfig.ReporterConfig{ // Configure how the client reports trace information. All fields are optional.
    LogSpans:          true,
    LocalAgentHostPort: endPoint,
    },
    // Token configuration
    Tags:        []opentracing.Tag{ // Set the tag, where information such as token can be stored.
    opentracing.Tag{Key: "token", Value: token}, // Set the token
    },
}
tracer, closer, err := cfg.NewTracer(jaegerConfig.Logger(jaeger.StdLogger)) // Get the tracer based on the configuration
3. Configure the interceptor.
s := grpc.NewServer(grpc.UnaryInterceptor(otgrpc.OpenTracingServerInterceptor(tracer)))
4. Start the server service.
// Register our service with the gRPC server
pb.RegisterHelloTraceServer(s, &server{})
if err := s.Serve(lis); err != nil {
   log.Fatalf("failed to serve: %v", err)
}
The complete code is as follows:
// Copyright © 2019-2020 Tencent Co., Ltd.

// This file is part of tencent project.
// Do not copy, cite, or distribute without the express
// permission from Cloud Monitor group.

package grpcdemo

import (
    "context"
    "fmt"
    "github.com/opentracing/opentracing-go"
    "github.com/uber/jaeger-client-go"
    jaegerConfig "github.com/uber/jaeger-client-go/config"
    "log"
    "net"

    "github.com/opentracing-contrib/go-grpc"
    "google.golang.org/grpc"
)

const (
    // Service name, which is the unique identifier of the service and the basis for service metric aggregation and filtering.
    grpcServerName = "demo-grpc-server"
    serverPort     = ":9090"
)

// server is used to implement proto.HelloTraceServer.
type server struct {
    UnimplementedHelloTraceServer
}

// SayHello implements proto.HelloTraceServer
func (s *server) SayHello(ctx context.Context, in *TraceRequest) (*TraceResponse, error) {
    log.Printf("Received: %v", in.GetName())
    return &TraceResponse{Message: "Hello " + in.GetName()}, nil
}

// StartServer
func StartServer() {
    cfg := &jaegerConfig.Configuration{
        ServiceName: grpcServerName, // Call trace of the target service. Enter the service name.
        Sampler: &jaegerConfig.SamplerConfig{ // Sampling policy configuration. See section 4.1.1 for details.
            Type:  "const",
            Param: 1,
        },
        Reporter: &jaegerConfig.ReporterConfig{ // Configure how the client reports trace information. All fields are optional.
            LogSpans:           true,
            LocalAgentHostPort: endPoint,
        },
        // Token configuration
        Tags: []opentracing.Tag{ // Set the tag, where information such as token can be stored.
            opentracing.Tag{Key: "token", Value: token}, // Set the token
        },
    }
    tracer, closer, err := cfg.NewTracer(jaegerConfig.Logger(jaeger.StdLogger)) // Get the tracer based on the configuration
    defer closer.Close()
    if err != nil {
        panic(fmt.Sprintf("ERROR: fail init Jaeger: %v\\n", err))
    }
    lis, err := net.Listen("tcp", serverPort)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer(grpc.UnaryInterceptor(otgrpc.OpenTracingServerInterceptor(tracer)))

    // Register our service with the gRPC server
    RegisterHelloTraceServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Client

1. Due to the need to simulate HTTP requests on the client, import the opentracing-contrib/go-stdlib/nethttp dependency.
Dependency path: github.com/opentracing-contrib/go-stdlib/nethttp
Version requirement: ≥ v1.0.0
2. Configure Jaeger and create a trace object.
cfg := &jaegerConfig.Configuration{
    ServiceName: grpcClientName, // Call trace of the target service. Enter the service name.
    Sampler: &jaegerConfig.SamplerConfig{ // Sampling policy configuration. See section 4.1.1 for details.
    Type:  "const",
    Param: 1,
    },
    Reporter: &jaegerConfig.ReporterConfig{ // Configure how the client reports trace information. All fields are optional.
    LogSpans:          true,
    LocalAgentHostPort: endPoint,
    },
    // Token configuration
    Tags:        []opentracing.Tag{ // Set the tag, where information such as token can be stored.
    opentracing.Tag{Key: "token", Value: token}, // Set the token
    },
}
tracer, closer, err := cfg.NewTracer(jaegerConfig.Logger(jaeger.StdLogger)) // Get the tracer based on the configuration
3. Establish a connection to configure the interceptor.
// Establish a connection to the server to configure the interceptor
conn, err := grpc.Dial(serverAddress, grpc.WithInsecure(), grpc.WithBlock(),
        grpc.WithUnaryInterceptor(otgrpc.OpenTracingClientInterceptor(tracer)))
4. Make a gRPC call to check whether the access is successful. The complete code is as follows:
// Copyright © 2019-2020 Tencent Co., Ltd.

// This file is part of tencent project.
// Do not copy, cite, or distribute without the express
// permission from Cloud Monitor group.

package grpcdemo

import (
    "context"
    "fmt"
    "github.com/opentracing-contrib/go-grpc"
    "github.com/opentracing/opentracing-go"
    "github.com/uber/jaeger-client-go"
    jaegerConfig "github.com/uber/jaeger-client-go/config"
    "google.golang.org/grpc"
    "log"
    "time"
)

const (
    // Service name, which is the unique identifier of the service and the basis for service metric aggregation and filtering.
    grpcClientName = "demo-grpc-client"
    defaultName    = "TAW Tracing"
    serverAddress  = "localhost:9090"
    endPoint       = "xxxxx:6831" // Local agent address
    token          = "abc"
)

// StartClient
func StartClient() {
    cfg := &jaegerConfig.Configuration{
        ServiceName: grpcClientName, // Call trace of the target service. Enter the service name.
        Sampler: &jaegerConfig.SamplerConfig{ // Sampling policy configuration. See section 4.1.1 for details.
            Type:  "const",
            Param: 1,
        },
        Reporter: &jaegerConfig.ReporterConfig{ // Configure how the client reports trace information. All fields are optional.
            LogSpans:           true,
            LocalAgentHostPort: endPoint,
        },
        // Token configuration
        Tags: []opentracing.Tag{ // Set the tag, where information such as token can be stored.
            opentracing.Tag{Key: "token", Value: token}, // Set the token
        },
    }
    tracer, closer, err := cfg.NewTracer(jaegerConfig.Logger(jaeger.StdLogger)) // Get the tracer based on the configuration
    defer closer.Close()
    if err != nil {
        panic(fmt.Sprintf("ERROR: fail init Jaeger: %v\\n", err))
    }
    // Establish a connection to the server to configure the interceptor
    conn, err := grpc.Dial(serverAddress, grpc.WithInsecure(), grpc.WithBlock(),
        grpc.WithUnaryInterceptor(otgrpc.OpenTracingClientInterceptor(tracer)))
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()

    //
    c := NewHelloTraceClient(conn)
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    // Make an RPC call
    r, err := c.SayHello(ctx, &TraceRequest{Name: defaultName})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("RPC Client receive: %s", r.GetMessage())
}

Was this page helpful?
You can also Contact Sales or Submit a Ticket for help.
Yes
No

Feedback

Contact Us

Contact our sales team or business advisors to help your business.

Contact Us
Technical Support

Open a ticket if you're looking for further assistance. Our Ticket is 7x24 available.

Submit a Ticket
7x24 Phone Support
Hong Kong, China
+852 800 906 020 (Toll Free)
United States
+1 844 606 0804 (Toll Free)
United Kingdom
+44 808 196 4551 (Toll Free)
Canada
+1 888 605 7930 (Toll Free)
Australia
+61 1300 986 386 (Toll Free)
EdgeOne hotline
+852 300 80699
More local hotlines coming soon