Address review feedback: use findJITRegion, restore Detach cleanup

- Restore findJITRegion() from base (open-telemetry#1102) which was incorrectly removed
  during rebase - PR #26 now reuses the shared function instead of inline code
- Remove redundant inline first-pass JIT detection (now handled by findJITRegion)
- Detach cleanup is inherited from the updated base (open-telemetry#1102)

Author: dalehamel

interpreter/ruby/ruby.go

@@ -1286,6 +1286,56 @@ func profileFrameFullLabel(classPath, label, baseLabel, methodName libpf.String,
 // On x86_64, frame pointers are only emitted when --yjit-perf or --yjit-perf=fp is used.
 // When --yjit-perf is active, YJIT also creates /tmp/perf-PID.map, which we use as the
 // detection signal on x86_64.
+// findJITRegion detects the YJIT JIT code region from process memory mappings.
+// YJIT reserves a large contiguous address range (typically 48-128 MiB) via mmap
+// with PROT_NONE and then mprotects individual 16k codepages to r-x as needed.
+// On systems with CONFIG_ANON_VMA_NAME, Ruby labels the region via prctl(PR_SET_VMA)
+// giving it a path like "[anon:Ruby:rb_yjit_reserve_addr_space]".
+// On systems without that config, we fall back to a heuristic: the first anonymous
+// executable mapping (by address) is assumed to be the JIT region since YJIT
+// initializes before any gems could create anonymous executable mappings.
+// Returns (start, end, found).
+func findJITRegion(mappings []process.RawMapping) (uint64, uint64, bool) {
+	var jitStart, jitEnd uint64
+	labelFound := false
+	var heuristicStart, heuristicEnd uint64
+	heuristicFound := false
+
+	for idx := range mappings {
+		m := &mappings[idx]
+
+		// Check for prctl-labeled JIT region. These mappings may be ---p (PROT_NONE)
+		// or r-xp depending on whether YJIT has activated codepages in this region.
+		if strings.Contains(m.Path, "jit_reserve_addr_space") {
+			if !labelFound || m.Vaddr < jitStart {
+				jitStart = m.Vaddr
+			}
+			if !labelFound || m.Vaddr+m.Length > jitEnd {
+				jitEnd = m.Vaddr + m.Length
+			}
+			labelFound = true
+			continue
+		}
+
+		// Heuristic fallback: first anonymous executable mapping by address.
+		// Mappings from /proc/pid/maps are sorted by address, so the first
+		// match is the lowest address.
+		if !heuristicFound && m.IsExecutable() && m.IsAnonymous() {
+			heuristicStart = m.Vaddr
+			heuristicEnd = m.Vaddr + m.Length
+			heuristicFound = true
+		}
+	}
+
+	if labelFound {
+		return jitStart, jitEnd, true
+	}
+	if heuristicFound {
+		return heuristicStart, heuristicEnd, true
+	}
+	return 0, 0, false
+}
+
 func hasJitFramePointers(pr process.Process) bool {
 	machine := pr.GetMachineData().Machine
 	if machine == elf.EM_AARCH64 {
@@ -1310,33 +1360,7 @@ func (r *rubyInstance) SynchronizeMappings(ebpf interpreter.EbpfHandler,
 
 	log.Debugf("Synchronizing ruby mappings")
 
-	// First pass: detect JIT bounds from ALL mappings (including non-executable).
-	// Ruby reserves a large address range for JIT code via mmap and labels it with
-	// prctl(PR_SET_VMA), giving it a path like "[anon:Ruby:rb_jit_reserve_addr_space]".
-	// The reserved region is typically ---p (non-executable). Ruby then mprotects individual
-	// pages to r-xp as JIT code is compiled. We need the full reserved region bounds for
-	// jit_start/jit_end so the eBPF program can recognize any PC within the JIT range,
-	// even as new pages are made executable.
-	var jitStart, jitEnd uint64
-	jitFound := false
-	for idx := range mappings {
-		m := &mappings[idx]
-		if strings.Contains(m.Path, "jit_reserve_addr_space") {
-			if !jitFound || m.Vaddr < jitStart {
-				jitStart = m.Vaddr
-			}
-			if !jitFound || m.Vaddr+m.Length > jitEnd {
-				jitEnd = m.Vaddr + m.Length
-			}
-			jitFound = true
-		}
-	}
-
-	// Second pass: register LPM prefixes for executable anonymous/JIT mappings.
-	// This only covers r-xp pages so the eBPF unwinder is invoked for JIT code that
-	// has actually been committed. If no labeled JIT region was found above, fall back
-	// to heuristic detection from executable anonymous mappings.
-	var heuristicJitMapping *process.RawMapping
+	// Register LPM prefixes for executable anonymous mappings.
 	for idx := range mappings {
 		m := &mappings[idx]
 		if !m.IsExecutable() || !m.IsAnonymous() {