-Dotel.resource.attributes=service.name=<serviceName> 
-Dotel.exporter.otlp.headers=Authentication=<Authentication> 
-Dotel.exporter.otlp.endpoint=<endpoint>
-javaagent:<javaagent>

import (
    "context"
    "errors"
    "io"
    "log"
    "net"
    "os"
    "time"

    "net/http"
    "os/signal"

    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

func setupOTelSDK(ctx context.Context) (shutdown func(context.Context) error, err error) {
    var shutdownFuncs []func(context.Context) error

    shutdown = func(ctx context.Context) error {
        var err error
        for _, fn := range shutdownFuncs {
            err = errors.Join(err, fn(ctx))
        }
        shutdownFuncs = nil
        return err
    }

    headers := map[string]string{"Authentication": "<Authentication>"} // <Authentication>替换为业务系统Authentication
    opts := []otlptracehttp.Option{
        otlptracehttp.WithHeaders(headers),
        otlptracehttp.WithEndpoint("<endpoint>"), // <endpoint> 填写上报地址，注意需要省略 http:// 前缀
        otlptracehttp.WithInsecure(),
    }
    client := otlptracehttp.NewClient(opts...)
    if err != nil {
        log.Fatal(err)
    }
    r, err := resource.New(ctx, []resource.Option{
        resource.WithAttributes(
            attribute.KeyValue{Key: "service.name", Value: attribute.StringValue("<serviceName>")}, // <serviceName>替换为应用名
            attribute.KeyValue{Key: "host.name", Value: attribute.StringValue("<hostName>")},       // <hostName>替换为IP地址
        ),
    }...)
    if err != nil {
        log.Fatal(err)
    }
    traceExp, err := otlptrace.New(ctx, client)
    if err != nil {
        log.Fatal(err)
    }
    bsp := sdktrace.NewBatchSpanProcessor(traceExp)
    tp := sdktrace.NewTracerProvider(
        sdktrace.WithSampler(sdktrace.AlwaysSample()),
        sdktrace.WithSpanProcessor(bsp),
        sdktrace.WithResource(r),
    )
    otel.SetTracerProvider(tp)
    otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
    return
}

func main() {
    if err := run(); err != nil {
        log.Fatalln(err)
    }
}

func run() (err error) {
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
    defer stop()

    // 初始化 SDK
    otelShutdown, err := setupOTelSDK(ctx)
    if err != nil {
        return
    }
    // 优雅关闭
    defer func() {
        err = errors.Join(err, otelShutdown(context.Background()))
    }()

    // 启动HTTP服务
    srv := &http.Server{
        Addr:         ":8080",
        BaseContext:  func(_ net.Listener) context.Context { return ctx },
        ReadTimeout:  time.Second,
        WriteTimeout: 10 * time.Second,
        Handler:      newHTTPHandler(),
    }
    srvErr := make(chan error, 1)
    go func() {
        srvErr <- srv.ListenAndServe()
    }()

    select {
    case err = <-srvErr:
        return
    case <-ctx.Done():
        stop()
    }

    err = srv.Shutdown(context.Background())
    return
}

func newHTTPHandler() http.Handler {
    mux := http.NewServeMux()

    handleFunc := func(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) {
        // 对HTTP路由进行埋点
        handler := otelhttp.WithRouteTag(pattern, http.HandlerFunc(handlerFunc))
        mux.Handle(pattern, handler)
    }

    // 注册接口
    handleFunc("/simple", simpleIOHandler)

    // 对所有接口进行埋点增强
    handler := otelhttp.NewHandler(mux, "/")
    return handler
}

func simpleIOHandler(w http.ResponseWriter, r *http.Request) {
    io.WriteString(w, "ok")
}

pip install opentelemetry-instrumentation-redis
pip install opentelemetry-instrumentation-mysql
pip install opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install

from flask import Flask
import requests
import time

backend_addr = 'https://example.com/'

app = Flask(__name__)

# 访问外部站点
@app.route('/')
def index():
    start = time.time()
    r = requests.get(backend_addr)
    return r.text

# 访问数据库
@app.route('/mysql')
def func_rdb():
    return "rdb res"

# 访问Redis
@app.route("/redis")
def func_kvop():
    return "kv res"

app.run(host='0.0.0.0', port=8080)

opentelemetry-instrument \
--traces_exporter otlp \
--service_name <serviceName> \
--exporter_otlp_endpoint <endpoint> \
--exporter_otlp_protocol http/protobuf \
--exporter_otlp_headers Authentication=<Authentication> \
--resource_attributes host.name=<hostName> \
python3 app.py