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

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>"} // Replace <Authentication> with the application system Authentication
    opts := []otlptracehttp.Option{
        otlptracehttp.WithHeaders(headers),
        otlptracehttp.WithEndpoint("<endpoint>"), // <endpoint> Enter the reporting address, omitting the http:// prefix
        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>")}, // Replace <serviceName> with application name
            attribute.KeyValue{Key: "host.name", Value: attribute.StringValue("<hostName>")},       // <hostName> Replace with an IP address
        ),
    }...)
    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()
    // Initialize SDK
    otelShutdown, err := setupOTelSDK(ctx)
    if err != nil {
        return
    }
    // Graceful shutdown
    defer func() {
        err = errors.Join(err, otelShutdown(context.Background()))
    }()
    // Start HTTP service
    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)) {
        // Instrument HTTP routes
        handler := otelhttp.WithRouteTag(pattern, http.HandlerFunc(handlerFunc))
        mux.Handle(pattern, handler)
    }
    // Register API
    handleFunc("/simple", simpleIOHandler)
    // Enhance instrumentation for all APIs
    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__)
# Access external site
@app.route('/')
def index():
    start = time.time()
    r = requests.get(backend_addr)
    return r.text
# Access database
@app.route('/mysql')
def func_rdb():
    return "rdb res"
# Access 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