Opentracing, не в состоянии вложить пролет в один и тот же след

Question

У меня есть конечная точка "/foo" и связанный с ней http-обработчик. Когда к этой конечной точке передается запрос get, запускается другая служба grpc.

Промежуточное программное обеспечение используется:

В моем примере я использую функцию промежуточного программного обеспечения go-stdlib / nethttp, чтобы обернуть мой обработчик "/foo" для прохождения трассирующего трассировщика.

На стороне Grpc я использую метод otgrpc "otgrpc.OpenTracingClientInterceptor", чтобы передать трассировщик.

Я получаю 2 пролета на моем сервере zipkin. Один для запроса GET и один для вызова GRPC - каждый в своей собственной трассе. Я не могу вкладывать пролеты в один и тот же след. В идеале я не должен получить дублирующую трассу, а скорее одну трассу с двумя промежутками в ней. Что-то вроде этого:

test_app ================================ trace
 /foo -----------------------------------span
            grpccall -------------------- span

Но вот что я получаю:

test_app ================================ trace
/foo ------------------------------------   span

test_app
grpc-------------------------------------  span

Поделиться моим примером кода здесь. Хотя я уверен, что мне нужно запустить диапазон и запустить дочерний диапазон из родительского диапазона, я не могу сделать это в этом конкретном фрагменте ограниченного кода.

Client.go

package main

import (
    "flag"
    "github.com/opentracing-contrib/go-stdlib/nethttp"
    "log"
    "net"
    "net/http"
    "os"

    "github.com/grpc-ecosystem/grpc-opentracing/go/otgrpc"
    "google.golang.org/grpc"
    pb "google.golang.org/grpc/examples/helloworld/helloworld"

    "/test_zipkin/internal/server"
    opentracing "github.com/opentracing/opentracing-go"
    zipkintracer "github.com/openzipkin/zipkin-go-opentracing"
)

var (
    zipkinURL  = "http://localhost:9411/api/v1/spans"
    serverPort = flag.String("port", "8000", "server port")
)

const (
    address         = "localhost:50051"
    defaultName     = "world"
    spansAPI        = "http://localhost:9411/api/v1/spans"
    serviceHostPort = "localhost:8000"
    serviceAddress  = "0.0.0.0:50051"
    serviceName     = "test_app"
)

func main() {

    logger1 := log.New(os.Stdout, log.Prefix(), log.Flags())
    var tracer opentracing.Tracer
    logger := zipkintracer.LogWrapper(logger1)

    collector, err := zipkintracer.NewHTTPCollector(
        spansAPI,
        zipkintracer.HTTPLogger(logger),
    )
    if err != nil {
        logger.Log("err", err)
        os.Exit(-1)
    }
    defer collector.Close()
    debug := true
    recorder := zipkintracer.NewRecorder(collector, debug, serviceAddress, serviceName)
    tracer, err = zipkintracer.NewTracer(
        recorder,
        zipkintracer.TraceID128Bit(true),
    )
    opentracing.InitGlobalTracer(tracer)

    if err != nil {
        logger.Log("err", err)
        os.Exit(-1)
    }

  //GRPC connection set up
    conn, err := grpc.Dial(address, grpc.WithInsecure(),
        grpc.WithUnaryInterceptor(
            otgrpc.OpenTracingClientInterceptor(tracer)),
    )
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    GreeterCLient := pb.NewGreeterClient(conn)
    w := server.New(GreeterCLient)

    httpMux := http.NewServeMux()
    foo := w

  //handler for foo endpoint
    {
        httpMux.Handle("/foo", nethttp.Middleware(tracer, foo))
    }

    s := &http.Server{
        Handler: httpMux,
        Addr:    *serverPort,
    }

    ln, err := net.Listen("tcp", "0.0.0.0:8089")

    if err != nil {
        log.Fatalf("Cannot initialize HTTP transport: %v", err)
    }
    s.Serve(ln)

}

Server.go:

package server

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "golang.org/x/net/context"
    "google.golang.org/grpc/examples/helloworld/helloworld"
)

type foo struct {
    GreeterClient helloworld.GreeterClient
}

const (
    defaultName = "foo"
)

func New(GreeterClient helloworld.GreeterClient) http.Handler {
    return &foo{
        GreeterClient: GreeterClient,
    }
}

func (f *foo) ServeHTTP(w http.ResponseWriter, req *http.Request) {

    fmt.Fprintf(w, "foo endpoint was called ... next making grpc call")

    // Contact the server and print out its response.
    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := f.GreeterClient.SayHello(ctx, &helloworld.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}