Fixed #TASK_GK-2944 Revert 兼容 Dotnet Aot 多次 return

This reverts commit 38a4f0f85cb7417f0c58e49bb322cb84b2fdea46.

containers/container.go

@@ -146,8 +146,11 @@ type Container struct {
 
 	done chan struct{}
 
-	traceMap   map[uint64]*tracing.Trace
-	instanceID utils.ID
+	traceMap      map[uint64]*tracing.Trace
+	instanceID    utils.ID
+	goEventStack  map[uint64]uint64
+	goEvents      map[uint64][]ebpftracer.StackFunEvent
+	goEventStacks map[uint64]map[uint64][]ebpftracer.StackFunEvent
 }
 
 func NewContainer(id ContainerID, cg *cgroup.Cgroup, md *ContainerMetadata, hostConntrack *Conntrack, pid uint32) (*Container, error) {
@@ -183,8 +186,10 @@ func NewContainer(id ContainerID, cg *cgroup.Cgroup, md *ContainerMetadata, host
 
 		hostConntrack: hostConntrack,
 
-		done:     make(chan struct{}),
-		traceMap: make(map[uint64]*tracing.Trace),
+		done:         make(chan struct{}),
+		traceMap:     make(map[uint64]*tracing.Trace),
+		goEventStack: map[uint64]uint64{},
+		goEvents:     map[uint64][]ebpftracer.StackFunEvent{},
 	}
 
 	for _, n := range md.networks {

containers/container_apm.go

@@ -8,6 +8,7 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/coroot/coroot-node-agent/ebpftracer"
 	"github.com/coroot/coroot-node-agent/ebpftracer/l7"
@@ -235,27 +236,28 @@ func (c *Container) StackProcess(event ebpftracer.StackEvent, tracer *ebpftracer
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	// get the associated uprobe
-	uprobe, err := c.GetUprobe(event, tracer)
-	if err != nil {
-		fmt.Println("GetUprobeGetUprobe errer: %v", err)
-		// log.Errorf("failed to get uprobe for event %+v: %+v", event, err)
-		return
-	}
-
-	if event.TraceId <= 0 {
-		fmt.Println("StackProcess TraceId id 0")
-		// log.Errorf("failed to get uprobe for event %+v: %+v", event, err)
-		return
-	}
+	switch event.Location {
+	case 0: // ret
+		uprobe, err := c.GetUprobe(event, tracer)
+		if err != nil {
+			fmt.Println("GetUprobeGetUprobe errer: %v", err)
+			// log.Errorf("failed to get uprobe for event %+v: %+v", event, err)
+			return
+		}
 
-	// fmt.Printf("StackProcess 函数入口开始处理 fun:TraceId:%lld, Funcname:%s, time: %lld\n", event.TraceId, uprobe.Funcname, event.TimeNsEnd-event.TimeNsStart)
-	stackFun := ebpftracer.StackFunEvent{}
-	stackFun.Uprobe = &uprobe
-	stackFun.StackEvent = event
+		if event.TraceId <= 0 {
+			fmt.Println("StackProcess TraceId id 0")
+			// log.Errorf("failed to get uprobe for event %+v: %+v", event, err)
+			return
+		}
 
-	apmTrace, ok := c.getTrace(event.TraceId)
-	if ok {
-		apmTrace.FunAdd(stackFun)
+		fmt.Printf("StackProcess 函数入口开始处理 fun:TraceId:%lld, Funcname:%s, time: %lld\n", event.TraceId, uprobe.Funcname, event.TimeNsEnd-event.TimeNsStart)
+		apmTrace, ok := c.getTrace(event.TraceId)
+		if ok {
+			fmt.Println("append FuncTraceQuery fun:", event.TraceId, uprobe.Funcname, event.Pid)
+			duration := event.TimeNsEnd - event.TimeNsStart
+			apmTrace.FuncTraceQuery(uprobe.Funcname, time.Duration(duration), event.TimeNsStart, event.TimeNsEnd)
+		}
 	}
 }
 
@@ -335,12 +337,12 @@ func (c *Container) GetUprobe(event ebpftracer.StackEvent, tracer *ebpftracer.Tr
 
 	memoryMap, _ := ReadFirstLineOfMapsFile(strconv.Itoa(int(event.Pid)))
 	Address := event.Ip - memoryMap.Start
-	// fmt.Printf("memoryMap.Start: %x, event.Ip: %x, Address: %x\n", memoryMap.Start, event.Ip, Address)
+	fmt.Printf("memoryMap.Start: %x, event.Ip: %x, Address: %x\n", memoryMap.Start, event.Ip, Address)
 
 	for _, fun := range tracer.UprobesMap {
-		funAddress := fun.Address + fun.AbsOffset
+		// funAddress := fun.Address + fun.AbsOffset
 		// fmt.Printf("GetUprobeGetUprobeGetUprobe:fun.Address %x, fun.AbsOffset: %x\n", fun.Address, fun.AbsOffset)
-		if funAddress == Address {
+		if fun.Address == Address {
 			// fmt.Printf("---GetUprobeGetUprobeGetUprobe: %x, event.Ip: %x\n", memoryMap.Start, event.Ip)
 			return fun, nil
 		}

containers/registry.go

@@ -52,6 +52,8 @@ type Registry struct {
 }
 
 var (
+	// goEvents map[uint64][]ebpftracer.StackFunEvent // k=goid,v=[]event
+	// goEventStack map[uint64]uint64
 	uprobes    []tracer.Uprobe
 	uprobesMap map[string]tracer.Uprobe
 )
@@ -301,12 +303,12 @@ func (r *Registry) handleEvents(ch <-chan ebpftracer.Event) {
 				}
 
 				if c := r.containersByPid[uint32(e.StackEvent.Pid)]; c != nil {
-					// fmt.Printf("e.EventTypeFunEnt: TraceId:%d, Pid:%d, Location:%d, Goid:%d, TimeNs:%d, Ip:%X, CallerIp:%x, Bp:%x, CallerBp:%x\n", e.StackEvent.TraceId, e.StackEvent.Pid, e.StackEvent.Location, e.StackEvent.Goid, e.StackEvent.TimeNsStart, e.StackEvent.Ip, e.StackEvent.CallerIp, e.StackEvent.Bp, e.StackEvent.CallerBp)
-					// fmt.Printf("e.EventTypeFunEnt: FPid:%x, Nid:%x, Level:%d\n", e.StackEvent.Fpid, e.StackEvent.Nid, e.StackEvent.Level)
+					fmt.Printf("e.EventTypeFunEnt: TraceId:%d, Pid:%d, Location:%d, Goid:%d, TimeNs:%d, Ip:%X, CallerIp:%x, Bp:%x, CallerBp:%x\n", e.StackEvent.TraceId, e.StackEvent.Pid, e.StackEvent.Location, e.StackEvent.Goid, e.StackEvent.TimeNsStart, e.StackEvent.Ip, e.StackEvent.CallerIp, e.StackEvent.Bp, e.StackEvent.CallerBp)
+					fmt.Printf("e.EventTypeFunEnt: FPid:%x, Nid:%x, Level:%d\n", e.StackEvent.Fpid, e.StackEvent.Nid, e.StackEvent.Level)
 					c.StackProcess(*e.StackEvent, r.tracer)
 				} else {
-					// fmt.Printf("e.EventTypeFunEnt ErrorError: TraceId:%d, Pid:%d, Location:%d, Goid:%d, TimeNs:%d, Ip:%X, CallerIp:%x, Bp:%x, CallerBp:%x", e.StackEvent.TraceId, e.StackEvent.Pid, e.StackEvent.Location, e.StackEvent.Goid, e.StackEvent.TimeNsStart, e.StackEvent.Ip, e.StackEvent.CallerIp, e.StackEvent.Bp, e.StackEvent.CallerBp)
-					// fmt.Printf("e.EventTypeFunEnt ErrorError: TraceId:%x, FPid:%x, Nid:%x, Level:%d\n", e.StackEvent.Fpid, e.StackEvent.Nid, e.StackEvent.Level)
+					fmt.Printf("e.EventTypeFunEnt ErrorError: TraceId:%d, Pid:%d, Location:%d, Goid:%d, TimeNs:%d, Ip:%X, CallerIp:%x, Bp:%x, CallerBp:%x", e.StackEvent.TraceId, e.StackEvent.Pid, e.StackEvent.Location, e.StackEvent.Goid, e.StackEvent.TimeNsStart, e.StackEvent.Ip, e.StackEvent.CallerIp, e.StackEvent.Bp, e.StackEvent.CallerBp)
+					fmt.Printf("e.EventTypeFunEnt ErrorError: TraceId:%x, FPid:%x, Nid:%x, Level:%d\n", e.StackEvent.Fpid, e.StackEvent.Nid, e.StackEvent.Level)
 				}
 			}
 		}

ebpftracer/ebpf/utrace/go/net/stack.probe.bpf.c

@@ -108,32 +108,32 @@ int ent(struct pt_regs *ctx)
 	cw_bpf_debug("[Go] [uprobe/ent]: event: location:%x,ip:%lx,time_ns_start:%lld\n", e->location, e->ip, e->time_ns_start);
 	cw_bpf_debug("[Go] [uprobe/ent]: event: bp:%x,caller_bp:%x,caller_ip:%x\n", e->bp,e->caller_bp,e->caller_ip);
 
-	// struct trace_stack_entry_key_t trace_key = {};
-	// trace_key.caller_bp = e->caller_bp % 0x800 + (e->goid << 12);
-	// trace_key.bp = e->bp % 0x800 + (e->goid << 12);
+	struct trace_stack_entry_key_t trace_key = {};
+	trace_key.caller_bp = e->caller_bp % 0x800 + (e->goid << 12);
+	trace_key.bp = e->bp % 0x800 + (e->goid << 12);
 
 	// trace_key.caller_bp = e->caller_bp;
 	// trace_key.bp = e->bp;
 	// cw_bpf_debug("[Go] [uprobe/ent]: trace_keytrace_keytrace_key: bp: %x", trace_key.bp);
-	// cw_bpf_debug("[Go] [uprobe/ent]: trace_keytrace_keytrace_key: caller_bp: %x, bp: %x", trace_key.caller_bp, trace_key.bp);
-
-	// struct event event_current = {};
-	// event_current.bp = e->bp,
-	// event_current.caller_bp = e->caller_bp,
-	// event_current.caller_ip = e->caller_ip,
-	// event_current.pid = e->pid,
-	// event_current.trace_id = e->trace_id,
-	// event_current.goid = e->goid,
-	// event_current.ip = e->ip,
-	// event_current.time_ns_start = e->time_ns_start,
-	// event_current.location = e->location,
-	// event_current.nid = ((e->ip % 0x1000) << 24) + e->bp % 0x800 + (e->goid << 12),
-	// event_current.fpid = e->caller_bp % 0x800 + (e->goid << 12),
-
-	// bpf_map_update_elem(&trace_stack_entry, &trace_key, &event_current, BPF_ANY);
+	cw_bpf_debug("[Go] [uprobe/ent]: trace_keytrace_keytrace_key: caller_bp: %x, bp: %x", trace_key.caller_bp, trace_key.bp);
+
+	struct event event_current = {};
+	event_current.bp = e->bp,
+	event_current.caller_bp = e->caller_bp,
+	event_current.caller_ip = e->caller_ip,
+	event_current.pid = e->pid,
+	event_current.trace_id = e->trace_id,
+	event_current.goid = e->goid,
+	event_current.ip = e->ip,
+	event_current.time_ns_start = e->time_ns_start,
+	event_current.location = e->location,
+	event_current.nid = ((e->ip % 0x1000) << 24) + e->bp % 0x800 + (e->goid << 12),
+	event_current.fpid = e->caller_bp % 0x800 + (e->goid << 12),
+
+	bpf_map_update_elem(&trace_stack_entry, &trace_key, &event_current, BPF_ANY);
 
 	// return bpf_map_push_elem(&event_queue, e, BPF_EXIST);
-	bpf_perf_event_output(ctx, &event_queue, BPF_F_CURRENT_CPU, e, sizeof(*e));
+	// bpf_perf_event_output(ctx, &event_queue, BPF_F_CURRENT_CPU, e, sizeof(*e));
 
 	cw_bpf_debug("[Go] [uprobe/ent] end");
 	return 1;
@@ -171,41 +171,41 @@ int ret(struct pt_regs *ctx)
 	e->ip = PT_REGS_IP(ctx);
 	e->time_ns_end = bpf_ktime_get_ns();
 	e->bp = PT_REGS_SP(ctx) - 8;
-	e->caller_bp = PT_REGS_FP(ctx);
 
-	cw_bpf_debug("[Go] [uprobe/ret]: e->ip:%lx,bp:%x,caller_bp:%x", e->ip, e->bp, e->caller_bp);
+	__u64 caller_bp = PT_REGS_FP(ctx);
+	cw_bpf_debug("[Go] [uprobe/ret]: e->ip:%lx,bp:%x,caller_bp:%x", e->ip, e->bp, caller_bp);
 	cw_bpf_debug("[Go] [uprobe/ret]: sp:%x, goid: %llu, goid:0x:%x", PT_REGS_SP(ctx), e->goid, e->goid);
 
 	cw_bpf_debug("[Go] [uprobe/ret]: event: location:%x,ip:%x,time_ns_end:%lld\n", e->location, e->ip, e->time_ns_end);
 
-	// struct trace_stack_entry_key_t trace_key = {};
-	// trace_key.caller_bp = caller_bp % 0x800 + (e->goid << 12);
-	// trace_key.bp = e->bp % 0x800 + (e->goid << 12);
+	struct trace_stack_entry_key_t trace_key = {};
+	trace_key.caller_bp = caller_bp % 0x800 + (e->goid << 12);
+	trace_key.bp = e->bp % 0x800 + (e->goid << 12);
 
 	// trace_key.caller_bp = caller_bp;
 	// trace_key.bp = e->bp;
 
-	// cw_bpf_debug("[Go] [uprobe/ret]: trace_keytrace_keytrace_key: caller_bp: %x, bp: %x", trace_key.caller_bp, trace_key.bp);
+	cw_bpf_debug("[Go] [uprobe/ret]: trace_keytrace_keytrace_key: caller_bp: %x, bp: %x", trace_key.caller_bp, trace_key.bp);
 	// cw_bpf_debug("[Go] [uprobe/ret]: trace_keytrace_keytrace_key: bp: %x", trace_key.bp);
 
-	// struct event *event_p = bpf_map_lookup_elem(&trace_stack_entry, &trace_key);
+	struct event *event_p = bpf_map_lookup_elem(&trace_stack_entry, &trace_key);
 
-	// if (!event_p) {
-	// 	cw_bpf_debug("[Go] [uprobe/ret]:ErrorErrorErrorError Not get funEntry");
-	// 	return 0;
-	// }
+	if (!event_p) {
+		cw_bpf_debug("[Go] [uprobe/ret]:ErrorErrorErrorError Not get funEntry");
+		return 0;
+	}
 
-	// event_p->time_ns_end = e->time_ns_end;
+	event_p->time_ns_end = e->time_ns_end;
 
-	// cw_bpf_debug("[Go] [uprobe/ret]: ent:event: location:%d,ip:%x,time_ns_start:%lld\n", event_p->location, event_p->ip, event_p->time_ns_start);
-	// cw_bpf_debug("[Go] [uprobe/ret]: ent:event: bp:%x,caller_bp:%x,caller_ip:%x\n", event_p->bp,event_p->caller_bp,event_p->caller_ip);
-	// cw_bpf_debug("[Go] [uprobe/ret]: ent:event: nid:%llx,fpid:%llx,level:%d\n", event_p->nid,event_p->fpid,event_p->level);
+	cw_bpf_debug("[Go] [uprobe/ret]: ent:event: location:%d,ip:%x,time_ns_start:%lld\n", event_p->location, event_p->ip, event_p->time_ns_start);
+	cw_bpf_debug("[Go] [uprobe/ret]: ent:event: bp:%x,caller_bp:%x,caller_ip:%x\n", event_p->bp,event_p->caller_bp,event_p->caller_ip);
+	cw_bpf_debug("[Go] [uprobe/ret]: ent:event: nid:%llx,fpid:%llx,level:%d\n", event_p->nid,event_p->fpid,event_p->level);
 
-	// bpf_map_delete_elem(&trace_stack_entry, &trace_key);
+	bpf_map_delete_elem(&trace_stack_entry, &trace_key);
 
 	// return bpf_map_push_elem(&event_queue, e, BPF_EXIST);
-	// cw_bpf_debug("[Go] [uprobe/ret]: ent:event_ret push: nid:%llx,fpid:%llx,level:%d\n", event_p->nid,event_p->fpid,event_p->level);
-	bpf_perf_event_output(ctx, &event_queue, BPF_F_CURRENT_CPU, e, sizeof(*e));
+	cw_bpf_debug("[Go] [uprobe/ret]: ent:event_ret push: nid:%llx,fpid:%llx,level:%d\n", event_p->nid,event_p->fpid,event_p->level);
+	bpf_perf_event_output(ctx, &event_queue, BPF_F_CURRENT_CPU, event_p, sizeof(*e));
 
 	cw_bpf_debug("[Go] [uprobe/ret] end");
 	return 1;
@@ -267,32 +267,32 @@ int dotnetent(struct pt_regs *ctx)
 	cw_bpf_debug("[Go] [uprobe/ent]: event: location:%x,ip:%lx,time_ns_start:%lld\n", e->location, e->ip, e->time_ns_start);
 	cw_bpf_debug("[Go] [uprobe/ent]: event: bp:%x,caller_bp:%x,caller_ip:%x\n", e->bp,e->caller_bp,e->caller_ip);
 
-	// struct trace_stack_entry_key_t trace_key = {};
-	// trace_key.caller_bp = e->caller_bp % 0x800 + (e->goid << 12);
-	// trace_key.bp = e->bp % 0x800 + (e->goid << 12);
+	struct trace_stack_entry_key_t trace_key = {};
+	trace_key.caller_bp = e->caller_bp % 0x800 + (e->goid << 12);
+	trace_key.bp = e->bp % 0x800 + (e->goid << 12);
 
 	// trace_key.caller_bp = e->caller_bp;
 	// trace_key.bp = e->bp;
 	// cw_bpf_debug("[Go] [uprobe/ent]: trace_keytrace_keytrace_key: bp: %x", trace_key.bp);
-	// cw_bpf_debug("[Go] [uprobe/ent]: trace_keytrace_keytrace_key: caller_bp: %x, bp: %x", trace_key.caller_bp, trace_key.bp);
-
-	// struct event event_current = {};
-	// event_current.bp = e->bp,
-	// event_current.caller_bp = e->caller_bp,
-	// event_current.caller_ip = e->caller_ip,
-	// event_current.pid = e->pid,
-	// event_current.trace_id = e->trace_id,
-	// event_current.goid = e->goid,
-	// event_current.ip = e->ip,
-	// event_current.time_ns_start = e->time_ns_start,
-	// event_current.location = e->location,
-	// event_current.nid = ((e->ip % 0x1000) << 24) + e->bp % 0x800 + (e->goid << 12),
-	// event_current.fpid = e->caller_bp % 0x800 + (e->goid << 12),
-
-	// bpf_map_update_elem(&trace_stack_entry, &trace_key, &event_current, BPF_ANY);
+	cw_bpf_debug("[Go] [uprobe/ent]: trace_keytrace_keytrace_key: caller_bp: %x, bp: %x", trace_key.caller_bp, trace_key.bp);
+
+	struct event event_current = {};
+	event_current.bp = e->bp,
+	event_current.caller_bp = e->caller_bp,
+	event_current.caller_ip = e->caller_ip,
+	event_current.pid = e->pid,
+	event_current.trace_id = e->trace_id,
+	event_current.goid = e->goid,
+	event_current.ip = e->ip,
+	event_current.time_ns_start = e->time_ns_start,
+	event_current.location = e->location,
+	event_current.nid = ((e->ip % 0x1000) << 24) + e->bp % 0x800 + (e->goid << 12),
+	event_current.fpid = e->caller_bp % 0x800 + (e->goid << 12),
+
+	bpf_map_update_elem(&trace_stack_entry, &trace_key, &event_current, BPF_ANY);
 
 	// return bpf_map_push_elem(&event_queue, e, BPF_EXIST);
-	bpf_perf_event_output(ctx, &event_queue, BPF_F_CURRENT_CPU, e, sizeof(*e));
+	// bpf_perf_event_output(ctx, &event_queue, BPF_F_CURRENT_CPU, e, sizeof(*e));
 
 	cw_bpf_debug("[Go] [uprobe/ent] end");
 	return 1;

ebpftracer/stack.go

@@ -73,8 +73,8 @@ func (t *Tracer) stack() error {
 	t.UprobesMap = map[string]tracer.Uprobe{}
 	fmt.Println("UprobesMap:::init")
 	for _, up := range t.Uprobes {
-		fmt.Println("UprobesMap:::", up.Funcname, up.Address, up.AbsOffset)
-		t.UprobesMap[fmt.Sprintf("%s-%s", up.Funcname, up.Address+up.AbsOffset)] = up
+		fmt.Println("UprobesMap:::", up.Funcname)
+		t.UprobesMap[fmt.Sprintf("%s-%s", up.Funcname, up.Address)] = up
 	}
 	links := t.attachUprobes(path, t.Uprobes)
 	t.links = append(t.links, links...)

ebpftracer/tracer.go

@@ -488,6 +488,9 @@ type StackEvent struct {
 type StackFunEvent struct {
 	StackEvent StackEvent
 	Uprobe     *tracer.Uprobe
+	Level      int
+	Pid        int
+	Nid        int
 }
 
 func runEventsReader(name string, r *perf.Reader, ch chan<- Event, typ perfMapType) {

pkg/go.opentelemetry.io/otel/exporters/otlp/otlptrace/apm_exporter.go

@@ -202,8 +202,8 @@ func buildLevel(sdl *TraceMapT) {
 	Nid := 2
 	level := 2
 
-	for _, v := range mapSlice {
-		// fmt.Println("SliceSliceindex", k, "value", v.Time, v.Type, v.Map.MethodName, v.Map.Nid)
+	for k, v := range mapSlice {
+		fmt.Println("SliceSliceindex", k, "value", v.Time, v.Type, v.Map.MethodName, v.Map.Nid)
 		if v.Type == 0 {
 			// 函数入口
 			funStack = append(funStack, v)

tracing/apm_tracing.go

@@ -3,12 +3,10 @@ package tracing
 import (
 	"context"
 	"fmt"
-	"sort"
 	"time"
 
 	"strconv"
 
-	"github.com/coroot/coroot-node-agent/ebpftracer"
 	"github.com/coroot/coroot-node-agent/ebpftracer/l7"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
@@ -33,79 +31,6 @@ func (t *Trace) setSpan(span trace.Span) {
 	t.span = span
 }
 
-type TimeMap struct {
-	Time uint64
-	Type int
-	Map  *ebpftracer.StackFunEvent
-}
-
-func (t *Trace) buildFun() {
-	mapSlice := []TimeMap{}
-	for i, v := range t.stack {
-		timeStartMap := TimeMap{}
-		if v.StackEvent.Location == 0 {
-			timeStartMap = TimeMap{
-				Time: v.StackEvent.TimeNsStart,
-				Type: 0,
-				Map:  &t.stack[i],
-			}
-		} else {
-			timeStartMap = TimeMap{
-				Time: v.StackEvent.TimeNsEnd,
-				Type: 1,
-				Map:  &t.stack[i],
-			}
-		}
-		mapSlice = append(mapSlice, timeStartMap)
-	}
-	sort.Slice(mapSlice, func(i, j int) bool {
-		return mapSlice[i].Time < mapSlice[j].Time
-	})
-
-	funStack := []TimeMap{}
-
-	currentfunNum := 1
-
-	// for k, v := range mapSlice {
-	// 	fmt.Println("---SliceSliceindex", k, "value", v.Time, v.Type, v.Map.Uprobe.Funcname, v.Map.StackEvent.Nid)
-	// }
-
-	mapSliceLen := len(mapSlice)
-	for k, v := range mapSlice {
-		// fmt.Println("SliceSliceindex", k, "value", v.Time, v.Type, v.Map.Uprobe.Funcname, v.Map.StackEvent.Nid)
-		if v.Type == 0 {
-			// 函数入口
-			funStack = append(funStack, v)
-		} else if v.Type == 1 {
-			// 函数出口
-			len := len(funStack)
-			if len < 1 {
-				fmt.Printf("buildFun ErrorError return before enter: %v\n", v)
-				continue
-			}
-			currnt := funStack[len-1]
-			if currnt.Map.StackEvent.Location != 0 {
-				fmt.Printf("currnt StackEvent ErrorError is not enter: %v\n", v)
-				continue
-			}
-			if k < mapSliceLen-1 && len >= 2 {
-				nextfun := mapSlice[k+1]
-				preCurrnt := funStack[len-2]
-				// // 处理 .netcore 多次 returun
-				// 下一个事件是 return 并且函数名跟当前事件是一样的，且上一个函数不是当前函数
-				if nextfun.Map.StackEvent.Location == 1 && nextfun.Map.Uprobe.Funcname == currnt.Map.Uprobe.Funcname && preCurrnt.Map.Uprobe.Funcname != currnt.Map.Uprobe.Funcname {
-					currentfunNum++
-					continue
-				}
-			}
-			funStack = funStack[:len-1]
-			duration := v.Map.StackEvent.TimeNsEnd - currnt.Map.StackEvent.TimeNsStart
-			t.FuncTraceQuery(currnt.Map.Uprobe.Funcname, time.Duration(duration), currnt.Map.StackEvent.TimeNsStart, v.Map.StackEvent.TimeNsEnd, currentfunNum)
-			currentfunNum = 1
-		}
-	}
-}
-
 func (t *Trace) TraceStart(method, path string, status l7.Status, duration time.Duration) {
 	if t == nil || method == "" {
 		return
@@ -144,10 +69,6 @@ func (t *Trace) TraceEnd(r *l7.RequestData) {
 	if r.ParentSpanContext.SpanIdFrom != "0000000000000000" {
 		t.span.SetAttributes(attribute.String("server.span_id_from", r.ParentSpanContext.SpanIdFrom))
 	}
-	// for _, v := range t.stack {
-	// 	fmt.Printf("TraceEndTraceEndTraceEnd%s\n", v)
-	// }
-	t.buildFun()
 	t.span.End(trace.WithTimestamp(time.Now()))
 }
 
@@ -226,11 +147,11 @@ func (t *Trace) HttpTraceRequest(method, path, ip string, port uint16, r *l7.Req
 	)
 }
 
-func (t *Trace) FuncTraceQuery(funcname string, duration time.Duration, start uint64, end uint64, num int) {
+func (t *Trace) FuncTraceQuery(funcname string, duration time.Duration, start uint64, end uint64) {
 	if t == nil || funcname == "" {
 		return
 	}
-	t.createTraceSpanNoTime(funcname, duration, false, start, end, attribute.Int("num", num))
+	t.createTraceSpanNoTime(funcname, duration, false, start, end)
 }
 
 func (t *Trace) createTraceSpanNoTime(name string, duration time.Duration, error bool, start uint64, end uint64, attrs ...attribute.KeyValue) {

tracing/tracing.go

@@ -4,11 +4,7 @@ import (
 	"context"
 	"fmt"
 
-	"sync"
-	"time"
-
 	"github.com/coroot/coroot-node-agent/common"
-	"github.com/coroot/coroot-node-agent/ebpftracer"
 	"github.com/coroot/coroot-node-agent/ebpftracer/l7"
 	"github.com/coroot/coroot-node-agent/flags"
 	"go.opentelemetry.io/otel/attribute"
@@ -21,6 +17,8 @@ import (
 	"go.opentelemetry.io/otel/trace"
 	"inet.af/netaddr"
 	"k8s.io/klog/v2"
+	"sync"
+	"time"
 )
 
 const (
@@ -80,7 +78,6 @@ type Trace struct {
 	ctx         context.Context
 	span        trace.Span
 	lock        sync.RWMutex
-	stack       []ebpftracer.StackFunEvent
 }
 
 func NewTrace(containerId string, destination netaddr.IPPort) *Trace {
@@ -196,7 +193,3 @@ func (t *Trace) RedisQuery(cmd, args string, error bool, duration time.Duration)
 		semconv.DBStatement(statement),
 	)
 }
-
-func (t *Trace) FunAdd(stackFun ebpftracer.StackFunEvent) {
-	t.stack = append(t.stack, stackFun)
-}