Support the capturing of environment variables

host/host.go

@@ -60,4 +60,5 @@ type Trace struct {
 	APMTraceID       libpf.APMTraceID
 	APMTransactionID libpf.APMTransactionID
 	CPU              int
+	EnvVars          map[string]string
 }

processmanager/processinfo.go

@@ -16,6 +16,9 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"slices"
+	"strconv"
+	"strings"
 	"syscall"
 	"time"
 
@@ -36,6 +39,15 @@ import (
 	"go.opentelemetry.io/ebpf-profiler/util"
 )
 
+type ProcessManagerConfig struct {
+	extractEnvVars []string
+}
+
+var pm_cfg = ProcessManagerConfig{extractEnvVars: []string{
+	"PIPELINE_PPOID",
+	"PIPELINE_SOFTWARENAME",
+	"PIPELINE_JOBID"}}
+
 // assignTSDInfo updates the TSDInfo for the Interpreters on given PID.
 // Caller must hold pm.mu write lock.
 func (pm *ProcessManager) assignTSDInfo(pid libpf.PID, tsdInfo *tpbase.TSDInfo) {
@@ -88,11 +100,26 @@ func (pm *ProcessManager) updatePidInformation(pid libpf.PID, m *Mapping) (bool,
 		if name, err := os.ReadFile(fmt.Sprintf("/prod/%d/comm", pid)); err == nil {
 			processName = string(name)
 		}
+
+		envVarMap := make(map[string]string)
+		if envVars, err := os.ReadFile(fmt.Sprintf("/proc/%d/environ", pid)); err == nil {
+			splittedVars := strings.Split(string(envVars), "\000")
+			fmt.Println("EnvVars for PID" + strconv.Itoa(int(pid)))
+			for _, envVar := range splittedVars {
+				keyValuePair := strings.Split(envVar, "=")
+				if slices.Contains(pm_cfg.extractEnvVars, keyValuePair[0]) {
+					envVarMap[keyValuePair[0]] = keyValuePair[1]
+					fmt.Println(envVar)
+				}
+			}
+		}
+
 		info = &processInfo{
 			name:             processName,
 			executable:       exePath,
 			mappings:         make(map[libpf.Address]*Mapping),
 			mappingsByFileID: make(map[host.FileID]map[libpf.Address]*Mapping),
+			envVariables:     envVarMap,
 			tsdInfo:          nil,
 		}
 		pm.pidToProcessInfo[pid] = info
@@ -730,3 +757,14 @@ func (pm *ProcessManager) ProcessedUntil(traceCaptureKTime times.KTime) {
 
 // Compile time check to make sure we satisfy the interface.
 var _ tracehandler.TraceProcessor = (*ProcessManager)(nil)
+
+func (pm *ProcessManager) EnvVarsForPID(pid libpf.PID) map[string]string {
+	var envVars map[string]string
+
+	pm.mu.RLock()
+	defer pm.mu.RUnlock()
+	if procInfo, ok := pm.pidToProcessInfo[pid]; ok {
+		envVars = procInfo.envVariables
+	}
+	return envVars
+}

processmanager/types.go

@@ -148,6 +148,8 @@ type processInfo struct {
 	mappingsByFileID map[host.FileID]map[libpf.Address]*Mapping
 	// C-library Thread Specific Data information
 	tsdInfo *tpbase.TSDInfo
+	// process env vars from /proc/PID/environ
+	envVariables map[string]string
 }
 
 // addMapping adds a mapping to the internal indices.

reporter/base_reporter.go

@@ -145,6 +145,7 @@ func (b *baseReporter) ReportTraceEvent(trace *libpf.Trace, meta *samples.TraceE
 		MappingFileOffsets: trace.MappingFileOffsets,
 		Timestamps:         []uint64{uint64(meta.Timestamp)},
 		OffTimes:           []int64{meta.OffTime},
+		EnvVars:            meta.EnvVars,
 	}
 }
 

reporter/internal/pdata/generate.go

@@ -11,6 +11,7 @@ import (
 	log "github.com/sirupsen/logrus"
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/pprofile"
+	"go.opentelemetry.io/otel/attribute"
 	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
 
 	"go.opentelemetry.io/ebpf-profiler/libpf"
@@ -206,6 +207,10 @@ func (p *Pdata) setProfile(
 		attrMgr.AppendInt(sample.AttributeIndices(),
 			semconv.ProcessPIDKey, traceKey.Pid)
 
+		for key, value := range traceInfo.EnvVars {
+			attrMgr.AppendOptionalString(sample.AttributeIndices(), attribute.Key("env."+key), value)
+		}
+
 		if p.ExtraSampleAttrProd != nil {
 			extra := p.ExtraSampleAttrProd.ExtraSampleAttrs(attrMgr, traceKey.ExtraMeta)
 			sample.AttributeIndices().Append(extra...)

reporter/samples/samples.go

@@ -15,6 +15,7 @@ type TraceEventMeta struct {
 	CPU            int
 	Origin         libpf.Origin
 	OffTime        int64
+	EnvVars        map[string]string
 }
 
 // TraceEvents holds known information about a trace.
@@ -27,6 +28,7 @@ type TraceEvents struct {
 	MappingFileOffsets []uint64
 	Timestamps         []uint64 // in nanoseconds
 	OffTimes           []int64  // in nanoseconds
+	EnvVars            map[string]string
 }
 
 // TraceAndMetaKey is the deduplication key for samples. This **must always**
@@ -44,6 +46,7 @@ type TraceAndMetaKey struct {
 	ProcessName string
 	// Executable path is retrieved from /proc/PID/exe
 	ExecutablePath string
+
 	// ExtraMeta stores extra meta info that may have been produced by a
 	// `SampleAttrProducer` instance. May be nil.
 	ExtraMeta any

support/ebpf/errors.h

@@ -121,8 +121,7 @@ typedef enum ErrorCode {
   // Native: Unable to read the IRQ stack link
   ERR_NATIVE_CHASE_IRQ_STACK_LINK = 4010,
 
-  // Native: Unexpectedly encountered a kernel mode pointer while attempting to unwind user-mode
-  // stack
+  // Native: Unexpectedly encountered a kernel mode pointer while attempting to unwind user-mode stack
   ERR_NATIVE_UNEXPECTED_KERNEL_ADDRESS = 4011,
 
   // Native: Unable to locate the PID page mapping for the current instruction pointer

tracehandler/tracehandler.go

@@ -129,6 +129,7 @@ func (m *traceHandler) HandleTrace(bpfTrace *host.Trace) {
 		ExecutablePath: bpfTrace.ExecutablePath,
 		Origin:         bpfTrace.Origin,
 		OffTime:        bpfTrace.OffTime,
+		EnvVars:        bpfTrace.EnvVars,
 	}
 
 	if !m.reporter.SupportsReportTraceEvent() {

tracer/tracer.go

@@ -990,6 +990,7 @@ func (t *Tracer) loadBpfTrace(raw []byte, cpu int) *host.Trace {
 		OffTime:          int64(ptr.offtime),
 		KTime:            times.KTime(ptr.ktime),
 		CPU:              cpu,
+		EnvVars:          t.processManager.EnvVarsForPID(pid),
 	}
 
 	if trace.Origin != support.TraceOriginSampling && trace.Origin != support.TraceOriginOffCPU {