fix

Author: wxiaoguang

modules/gtprof/trace.go

@@ -5,7 +5,10 @@ package gtprof
 
 import (
 	"context"
+	"crypto/rand"
+	"encoding/hex"
 	"fmt"
+	mathRand "math/rand/v2"
 	"sync"
 	"time"
 
@@ -36,6 +39,7 @@ type TraceSpan struct {
 
 	// mutable, must be protected by mutex
 	mu         sync.RWMutex
+	id         string
 	name       string
 	statusCode uint32
 	statusDesc string
@@ -54,6 +58,11 @@ type TraceValue struct {
 	v any
 }
 
+func (t *TraceValue) IsString() bool {
+	_, ok := t.v.(string)
+	return ok
+}
+
 func (t *TraceValue) AsString() string {
 	return fmt.Sprint(t.v)
 }
@@ -71,6 +80,7 @@ func (t *TraceValue) AsFloat64() float64 {
 var globalTraceStarters []traceStarter
 
 type Tracer struct {
+	chacha8  *mathRand.ChaCha8
 	starters []traceStarter
 }
 
@@ -113,7 +123,7 @@ func (t *Tracer) Start(ctx context.Context, spanName string) (context.Context, *
 	if starters == nil {
 		starters = globalTraceStarters
 	}
-	ts := &TraceSpan{name: spanName, startTime: time.Now()}
+	ts := &TraceSpan{id: t.randomHexForBytes(8), name: spanName, startTime: time.Now()}
 	parentSpan := GetContextSpan(ctx)
 	if parentSpan != nil {
 		parentSpan.mu.Lock()
@@ -165,8 +175,19 @@ func (s *TraceSpan) End() {
 	}
 }
 
+func (t *Tracer) randomHexForBytes(n int) string {
+	b := make([]byte, n)
+	_, _ = t.chacha8.Read(b) // it never fails
+	return hex.EncodeToString(b)
+}
+
 func GetTracer() *Tracer {
-	return &Tracer{}
+	var seed [32]byte
+	_, err := rand.Read(seed[:])
+	if err != nil {
+		panic(fmt.Sprintf("rand.Read: %v", err))
+	}
+	return &Tracer{chacha8: mathRand.NewChaCha8(seed)}
 }
 
 func GetContextSpan(ctx context.Context) *TraceSpan {

modules/gtprof/trace_builtin.go

@@ -78,6 +78,7 @@ func (t *traceBuiltinSpan) end() {
 			t.toString(sb, 0)
 			tailmsg.GetManager().GetTraceRecorder().Record(sb.String())
 		}
+		GetDefaultOtelExporter().recordTrace(t)
 	}
 }
 

modules/gtprof/trace_otel.go

@@ -0,0 +1,139 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gtprof
+
+import (
+	"bytes"
+	"net/http"
+	"strconv"
+
+	"code.gitea.io/gitea/modules/json"
+)
+
+type OtelAttributeStringValue struct {
+	StringValue string `json:"stringValue"`
+}
+
+type OtelAttributeIntValue struct {
+	IntValue string `json:"intValue"`
+}
+
+type OtelAttribute struct {
+	Key   string `json:"key"`
+	Value any    `json:"value"`
+}
+
+type OtelResource struct {
+	Attributes []*OtelAttribute `json:"attributes,omitempty"`
+}
+
+type OtelScope struct {
+	Name       string           `json:"name"`
+	Version    string           `json:"version"`
+	Attributes []*OtelAttribute `json:"attributes,omitempty"`
+}
+
+type OtelSpan struct {
+	TraceID           string           `json:"traceId"`
+	SpanID            string           `json:"spanId"`
+	ParentSpanID      string           `json:"parentSpanId,omitempty"`
+	Name              string           `json:"name"`
+	StartTimeUnixNano string           `json:"startTimeUnixNano"`
+	EndTimeUnixNano   string           `json:"endTimeUnixNano"`
+	Kind              int              `json:"kind"`
+	Attributes        []*OtelAttribute `json:"attributes,omitempty"`
+}
+
+type OtelScopeSpan struct {
+	Scope *OtelScope  `json:"scope"`
+	Spans []*OtelSpan `json:"spans"`
+}
+
+type OtelResourceSpan struct {
+	Resource   *OtelResource    `json:"resource"`
+	ScopeSpans []*OtelScopeSpan `json:"scopeSpans"`
+}
+
+type OtelTrace struct {
+	ResourceSpans []*OtelResourceSpan `json:"resourceSpans"`
+}
+
+type OtelExporter struct{}
+
+func (e *OtelExporter) toOtelSpan(traceID string, t *traceBuiltinSpan, scopeSpan *OtelScopeSpan) {
+	t.ts.mu.RLock()
+	defer t.ts.mu.RUnlock()
+
+	span := &OtelSpan{
+		TraceID:           traceID,
+		SpanID:            t.ts.id,
+		Name:              t.ts.name,
+		StartTimeUnixNano: strconv.FormatInt(t.ts.startTime.UnixNano(), 10),
+		EndTimeUnixNano:   strconv.FormatInt(t.ts.endTime.UnixNano(), 10),
+		Kind:              2,
+	}
+
+	if t.ts.parent != nil {
+		span.ParentSpanID = t.ts.parent.id
+	}
+
+	scopeSpan.Spans = append(scopeSpan.Spans, span)
+
+	for _, a := range t.ts.attributes {
+		var otelVal any
+		if a.Value.IsString() {
+			otelVal = OtelAttributeStringValue{a.Value.AsString()}
+		} else {
+			otelVal = OtelAttributeIntValue{strconv.FormatInt(a.Value.AsInt64(), 10)}
+		}
+		span.Attributes = append(span.Attributes, &OtelAttribute{Key: a.Key, Value: otelVal})
+	}
+
+	for _, c := range t.ts.children {
+		child := c.internalSpans[t.internalSpanIdx].(*traceBuiltinSpan)
+		e.toOtelSpan(traceID, child, scopeSpan)
+	}
+}
+
+func (e *OtelExporter) recordTrace(t *traceBuiltinSpan) {
+	var spans []*OtelSpan
+
+	scopeSpan := &OtelScopeSpan{
+		Scope: &OtelScope{
+			Name:    "gitea-web",
+			Version: "1.0", // FIXME: get version from somewhere
+		},
+		Spans: spans,
+	}
+
+	traceID := GetTracer().randomHexForBytes(16)
+	e.toOtelSpan(traceID, t, scopeSpan)
+
+	resSpans := OtelResourceSpan{
+		Resource: &OtelResource{
+			Attributes: []*OtelAttribute{
+				{Key: "service.name", Value: OtelAttributeStringValue{"gitea"}},
+			},
+		},
+		ScopeSpans: []*OtelScopeSpan{scopeSpan},
+	}
+
+	otelTrace := &OtelTrace{ResourceSpans: []*OtelResourceSpan{&resSpans}}
+
+	// TODO: use a async queue
+	otelTraceJSON, err := json.Marshal(otelTrace)
+	if err == nil {
+		_, _ = http.Post("http://localhost:4318/v1/traces", "application/json", bytes.NewReader(otelTraceJSON))
+	}
+}
+
+var defaultOtelExporter = NewOtelExporter()
+
+func GetDefaultOtelExporter() *OtelExporter {
+	return defaultOtelExporter
+}
+
+func NewOtelExporter() *OtelExporter {
+	return &OtelExporter{}
+}