trace.go

trace.go

func newResource(hostname, version, serviceName string) *resource.Resource {
	return resource.NewWithAttributes(
		semconv.SchemaURL,
		semconv.ServiceNameKey.String(serviceName),
		semconv.ServiceVersionKey.String(version),
		semconv.ServiceInstanceIDKey.String(hostname),
		semconv.TelemetrySDKLanguageGo,
		semconv.TelemetrySDKVersionKey.String("1.7.0"),
		semconv.TelemetrySDKNameKey.String("opentelemetry"),
	)
}

func (t *Telemetry) Start(ctx context.Context) (func(time.Duration), error) {
	svc := newResource(t.Metadata.Hostname, t.Metadata.KtoolsBuildVersion, t.Metadata.Name)
	
	if !t.cfg.Enabled {
		return func(shutdownTimeout time.Duration) {
			t.logger.Info().Msg("fake closing telemetry")
		}, nil
	}
	
	tracerClient := otlptracegrpc.NewClient(
		otlptracegrpc.WithCompressor("gzip"),
		otlptracegrpc.WithEndpoint(t.cfg.TraceEndpoint), otlptracegrpc.WithHeaders(map[string]string{
			"api-key":                t.cfg.NewrelicLicense,
			"lightstep-access-token": t.cfg.LightstepToken,
		}))
	
	traceExporter, err := otlptrace.New(ctx, tracerClient)
	
	if err != nil {
		return nil, errors.Wrap(err, "failed to create otlp trace exporter")
	}
	
	tracerProvider := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(traceExporter, sdktrace.WithMaxQueueSize(1)),
		sdktrace.WithResource(svc),
	)
	
	otel.SetTracerProvider(tracerProvider)
	
	metricsClient := otlpmetricgrpc.NewClient(
		otlpmetricgrpc.WithCompressor("gzip"),
		otlpmetricgrpc.WithEndpoint(t.cfg.MetricsEndpoint),
		otlpmetricgrpc.WithHeaders(map[string]string{"api-key": t.cfg.NewrelicLicense, "lightstep-access-token": t.cfg.LightstepToken}),
	)
	metricExporter, err := otlpmetric.New(ctx, metricsClient)
	
	if err != nil {
		return nil, errors.Wrap(err, "failed to create otlp metrics exporter")
	}
	
	metricPusher := metriccontroller.New(
		metricprocessor.NewFactory(
			simple.NewWithHistogramDistribution(),
			metricExporter,
		),
		metriccontroller.WithResource(svc),
		metriccontroller.WithExporter(metricExporter),
		metriccontroller.WithCollectPeriod(2*time.Second),
	)
	
	global.SetMeterProvider(metricPusher)
	
	if err := runtime.Start(runtime.WithMinimumReadMemStatsInterval(time.Second)); err != nil {
		return nil, err
	}
	
	if err = metricPusher.Start(ctx); err != nil {
		return nil, errors.Wrap(err, "failed to start metrics controller")
	}

	return func(shutdownTimeout time.Duration) {
		ctxTimeout, cancel := context.WithTimeout(ctx, shutdownTimeout)
		defer cancel()
		t.logger.Info().Msg("stopping metrics pusher")
		// pushes any last exports to the receiver
		if err := metricPusher.Stop(ctxTimeout); err != nil {
			otel.Handle(err)
		}
	
		t.logger.Info().Msg("stopping trace provider")
	
		if err := tracerProvider.Shutdown(ctxTimeout); err != nil {
			otel.Handle(err)
		}
	
	}, nil
}