【可观测链路】多语言 Opentelemetry SDK 接入实践

import (
    "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
)
router := gin.Default()
router.Use(otelgin.Middleware("GoGinMiddleware"))

// 从 context 中提取 trace 信息并向 HTTP 请求头中注入
func InjectTrace(req *http.Request, c context.Context) {
	ctx, req := otelhttptrace.W3C(c, req)
	otelhttptrace.Inject(ctx, req)
}
// 对 net/http 库提供的 client.Do 方法进行一层封装
func Do(ctx *gin.Context, c *http.Client, req *http.Request) (*http.Response, error) {
    InjectTrace(req, ctx.Request.Context())
    resp, err := c.Do(req)
    return resp, err
}

// 初始化opentracing
func OpentracingInit(addr, tenantId, serviceName string, ratio float64, modName string) {
    if err := tpstelemetry.Setup(addr, // 设置上报地址
        tpstelemetry.WithTenantID(tenantId),         
	tpstelemetry.WithServiceName(serviceName),         // 设置服务名，选填
	tpstelemetry.WithSampler(sdktrace.AlwaysSample()), // 设置采样策略，此为全量采样
    }
}

// 开启本次请求的链路跟踪
func InitTracing(ctx *gin.Context, name string) *OpentracingObjectSpan {
	// 从gin.Context中提取trace信息生成SpanContext, 开启 parent span
	c, parentSpan := tpstelemetry.GlobalTracer().Start(ctx.Request.Context(), moduleName+name)
	ctx.Request = ctx.Request.WithContext(c)
	parentSpan.SetAttributes(attribute.Key("span_kind").String(name))
	opentracingObjectSpan := OpentracingObjectSpan{name: name, sp: parentSpan}
	return &opentracingObjectSpan
}

// 结束本次请求的链路跟踪
func EndTracing(ctx *gin.Context, os *OpentracingObjectSpan, tags, logs map[string]interface{}) {
	os.sp.SetAttributes(api.TpsDyeingKey.String("OpenTestParent"))
	os.EndSpan(ctx, tags, logs)  // 结束 parent span
	if spanJSON, err := os.sp.SpanContext().MarshalJSON(); err == nil {
		log.Debug("Tracing Span:%s", string(spanJSON))
	}
}

// 设置远程上报地址(这里注意是HTTP地址)
const exporter = new OTLPTraceExporter({
      url: 'http://test.telemetry.woa.com:55681/v1/traces',
})
// 设置租户, 业务名等信息
const provider = new WebTracerProvider();
provider.addSpanProcessor(new BatchSpanProcessor(exporter));
provider.resource.attributes['tps.tenant.id'] = 'test';
provider.resource.attributes['service.name'] = "test-service";

provider.register({
    contextManager: new ZoneContextManager(),
    propagator: new W3CTraceContextPropagator(), // 注册W3C格式的传播器, 自动在HTTP Header中添加traceparent字段
});
  
// 注册XMLHttpRequest插件, 将自动跟踪xhr请求
registerInstrumentations({
instrumentations: [
    new XMLHttpRequestInstrumentation({
    ignoreUrls: [/localhost:8090\/sockjs-node/],
    propagateTraceHeaderCorsUrls: [
        `/http:\/\/localhost:7777.*/`
    ],
    }),
],
});

const startTrace = (url, fn)=>{
  // 创建 trace 
  const webTracerWithZone = provider.getTracer('tracer-web');
  // 创建 Span
  const singleSpan = webTracerWithZone.startSpan(url);
  // 以 singleSpan 作为父 Span, 将其与 xhr 请求时自动生成的 Span 串联起来
  context.with(trace.setSpan(context.active(), singleSpan), () => {
      const promise = typeof fn ==='function' ? fn() : fn;
      promise?.then((_data) => {
          trace.getSpan(context.active()).addEvent('log'); // 增加事件
          singleSpan.end();
      }).catch(err=>{
          trace.getSpan(context.active()).addEvent('log-err');
          singleSpan.end();
      });
  });
}
export default startTrace;

instrumentations: [
    new XMLHttpRequestInstrumentation({
    ignoreUrls: [/localhost:8090\/sockjs-node/],
    propagateTraceHeaderCorsUrls: [
        `/http:\/\/localhost:7777.*/`
    ],
    })
]

providerWithZone.register({
  contextManager: new ZoneContextManager(),
  propagator: new B3Propagator(),
});

// 设置上报地址
const exporter = new OTLPTraceExporter({
    url: 'http://xxxx.xxx.com',
});

module.exports = (serviceName) => {
  // 初始化业务名等
  const provider = new NodeTracerProvider({
    resource: new Resource({
      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
    }),
  });
  provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
  provider.register();

  // 在HTTP请求时自动注入trace信息
  registerInstrumentations({
    instrumentations: [
      new HttpInstrumentation(),
    ],
  });

  return opentelemetry.trace.getTracer('http-example');
};

// 测试发送http请求
function makeRequest() {
  const span = tracer.startSpan('makeRequest');
  api.context.with(api.trace.setSpan(api.context.active(), span), () => {
    http.get({
      host: 'localhost',
      port: 8080,
      path: '/helloworld',
    }, (response) => {
        // ...
      });
    });
  });
}