Propagate root session ID via cross-platform SHM carrier

Replaces exclusive env var propagation with a shared memory carrier:
- Linux:   memfd_create("dd-session-ids") without MFD_CLOEXEC; child
           discovers via /proc/self/fd/ scan
- macOS:   shm_open("/dd-session-ids-<pid>"); child opens by getppid()
- Windows: CreateFileMapping("Local\dd-session-ids-<pid>"); child
           opens by Toolhelp32-resolved parent PID

Tracer creates the carrier on startup and keeps it alive as a member.
finalize_config() prefers SHM on read, falls back to the env var for
interop with SDKs that still use _DD_ROOT_CPP_SESSION_ID.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: khanayan123

include/datadog/tracer.h

@@ -33,6 +33,7 @@ class TraceSampler;
 class SpanSampler;
 class IDGenerator;
 class InMemoryFile;
+class SessionCarrier;
 
 class Tracer {
   std::shared_ptr<Logger> logger_;
@@ -51,6 +52,7 @@ class Tracer {
   // read to determine if the process is instrumented with a tracer and to
   // retrieve relevant tracing information.
   std::shared_ptr<InMemoryFile> metadata_file_;
+  std::shared_ptr<SessionCarrier> session_carrier_;
   Baggage::Options baggage_opts_;
   bool baggage_injection_enabled_;
   bool baggage_extraction_enabled_;

src/datadog/platform_util.h

@@ -24,6 +24,30 @@
 namespace datadog {
 namespace tracing {
 
+// SessionCarrier: cross-platform inheritable shared memory segment for
+// propagating the root session ID to exec'd child processes.
+//
+// The parent creates a carrier before exec()'ing a child. The child calls
+// read_inherited_session_id() at startup to recover the root session ID.
+class SessionCarrier final {
+  void* handle_ = nullptr;
+
+  explicit SessionCarrier(void* handle);
+
+ public:
+  SessionCarrier(const SessionCarrier&) = delete;
+  SessionCarrier& operator=(const SessionCarrier&) = delete;
+  SessionCarrier(SessionCarrier&&) noexcept;
+  SessionCarrier& operator=(SessionCarrier&&) noexcept;
+  ~SessionCarrier();
+
+  static Expected<SessionCarrier> create(StringView root_session_id);
+};
+
+// Returns the root session ID inherited from a parent tracer via shared
+// memory. Returns nullopt if no carrier is found.
+Optional<std::string> read_inherited_session_id();
+
 // A wrapper around an in-memory file descriptor.
 //
 // This class provides a simple interface to create an in-memory file, write

src/datadog/platform_util_darwin.cpp

@@ -1,5 +1,7 @@
+#include <fcntl.h>
 #include <libproc.h>
 #include <pthread.h>
+#include <sys/mman.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
@@ -9,6 +11,7 @@
 #include <cstdint>
 #include <fstream>
 #include <regex>
+#include <string>
 
 #include "platform_util.h"
 
@@ -79,6 +82,56 @@ int at_fork_in_child(void (*on_fork)()) {
                         /*in child*/ on_fork);
 }
 
+SessionCarrier::SessionCarrier(void* handle) : handle_(handle) {}
+
+SessionCarrier::SessionCarrier(SessionCarrier&& rhs) noexcept {
+  std::swap(handle_, rhs.handle_);
+}
+
+SessionCarrier& SessionCarrier::operator=(SessionCarrier&& rhs) noexcept {
+  std::swap(handle_, rhs.handle_);
+  return *this;
+}
+
+SessionCarrier::~SessionCarrier() {
+  if (!handle_) return;
+  auto* name = static_cast<std::string*>(handle_);
+  shm_unlink(name->c_str());
+  delete name;
+}
+
+Expected<SessionCarrier> SessionCarrier::create(StringView root_session_id) {
+  std::string name = "/dd-session-ids-" + std::to_string(::getpid());
+  shm_unlink(name.c_str());  // remove any stale segment
+  int fd = shm_open(name.c_str(), O_CREAT | O_RDWR, 0600);
+  if (fd == -1) {
+    return Error{Error::Code::OTHER, "shm_open failed"};
+  }
+  const std::string data{root_session_id};
+  ftruncate(fd, static_cast<off_t>(data.size()));
+  ::write(fd, data.data(), data.size());
+  close(fd);
+  return SessionCarrier(new std::string{name});
+}
+
+Optional<std::string> read_inherited_session_id() {
+  std::string name = "/dd-session-ids-" + std::to_string(::getppid());
+  int fd = shm_open(name.c_str(), O_RDONLY, 0);
+  if (fd == -1) return nullopt;
+  struct stat st;
+  if (fstat(fd, &st) != 0 || st.st_size == 0) {
+    close(fd);
+    return nullopt;
+  }
+  void* mem = mmap(nullptr, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+  close(fd);
+  if (mem == MAP_FAILED) return nullopt;
+  std::string result(static_cast<const char*>(mem),
+                     static_cast<size_t>(st.st_size));
+  munmap(mem, st.st_size);
+  return result;
+}
+
 InMemoryFile::InMemoryFile(void* handle) : handle_(handle) {}
 
 InMemoryFile::~InMemoryFile() {}

src/datadog/platform_util_unix.cpp

@@ -1,3 +1,4 @@
+#include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
@@ -9,7 +10,10 @@
 #include <unistd.h>
 
 #include <cassert>
+#include <cstdio>
 #include <cstdint>
+#include <cstdlib>
+#include <cstring>
 #include <fstream>
 #include <regex>
 #include <string>
@@ -93,6 +97,70 @@ int at_fork_in_child(void (*on_fork)()) {
                         /*in child*/ on_fork);
 }
 
+SessionCarrier::SessionCarrier(void* handle) : handle_(handle) {}
+
+SessionCarrier::SessionCarrier(SessionCarrier&& rhs) noexcept {
+  std::swap(handle_, rhs.handle_);
+}
+
+SessionCarrier& SessionCarrier::operator=(SessionCarrier&& rhs) noexcept {
+  std::swap(handle_, rhs.handle_);
+  return *this;
+}
+
+SessionCarrier::~SessionCarrier() {
+  if (!handle_) return;
+  int* fd_ptr = static_cast<int*>(handle_);
+  close(*fd_ptr);
+  delete fd_ptr;
+}
+
+Expected<SessionCarrier> SessionCarrier::create(StringView root_session_id) {
+  // Omit MFD_CLOEXEC so the fd survives exec() and is visible to children.
+  int fd = memfd_create("dd-session-ids", MFD_ALLOW_SEALING);
+  if (fd == -1) {
+    return Error{Error::Code::OTHER,
+                 "memfd_create failed: " + std::to_string(errno)};
+  }
+  const std::string data{root_session_id};
+  if (::write(fd, data.data(), data.size()) !=
+      static_cast<ssize_t>(data.size())) {
+    close(fd);
+    return Error{Error::Code::OTHER,
+                 "SessionCarrier write failed: " + std::to_string(errno)};
+  }
+  fcntl(fd, F_ADD_SEALS,
+        F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_SEAL);
+  return SessionCarrier(new int{fd});
+}
+
+Optional<std::string> read_inherited_session_id() {
+  DIR* dir = opendir("/proc/self/fd");
+  if (!dir) return nullopt;
+  struct dirent* entry;
+  while ((entry = readdir(dir)) != nullptr) {
+    int fd = std::atoi(entry->d_name);
+    if (fd <= 2) continue;
+    char link_path[64];
+    std::snprintf(link_path, sizeof(link_path), "/proc/self/fd/%d", fd);
+    char target[256];
+    ssize_t len = readlink(link_path, target, sizeof(target) - 1);
+    if (len <= 0) continue;
+    target[len] = '\0';
+    if (std::strncmp(target, "memfd:dd-session-ids", 20) != 0) continue;
+    struct stat st;
+    if (fstat(fd, &st) != 0 || st.st_size == 0) continue;
+    void* mem = mmap(nullptr, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+    if (mem == MAP_FAILED) continue;
+    std::string result(static_cast<const char*>(mem), st.st_size);
+    munmap(mem, st.st_size);
+    closedir(dir);
+    return result;
+  }
+  closedir(dir);
+  return nullopt;
+}
+
 InMemoryFile::InMemoryFile(void* handle) : handle_(handle) {}
 
 InMemoryFile::InMemoryFile(InMemoryFile&& rhs) {

src/datadog/platform_util_windows.cpp

@@ -2,6 +2,7 @@
 #include <windows.h>
 // clang-format on
 #include <processthreadsapi.h>
+#include <tlhelp32.h>
 #include <winsock.h>
 
 #include <cassert>
@@ -141,6 +142,86 @@ int at_fork_in_child(void (*on_fork)()) {
   return 0;
 }
 
+namespace {
+
+DWORD get_parent_process_id() {
+  HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+  if (snapshot == INVALID_HANDLE_VALUE) return 0;
+  PROCESSENTRY32 pe;
+  pe.dwSize = sizeof(pe);
+  DWORD own_pid = GetCurrentProcessId();
+  DWORD ppid = 0;
+  if (Process32First(snapshot, &pe)) {
+    do {
+      if (pe.th32ProcessID == own_pid) {
+        ppid = pe.th32ParentProcessID;
+        break;
+      }
+    } while (Process32Next(snapshot, &pe));
+  }
+  CloseHandle(snapshot);
+  return ppid;
+}
+
+}  // namespace
+
+SessionCarrier::SessionCarrier(void* handle) : handle_(handle) {}
+
+SessionCarrier::SessionCarrier(SessionCarrier&& rhs) noexcept {
+  std::swap(handle_, rhs.handle_);
+}
+
+SessionCarrier& SessionCarrier::operator=(SessionCarrier&& rhs) noexcept {
+  std::swap(handle_, rhs.handle_);
+  return *this;
+}
+
+SessionCarrier::~SessionCarrier() {
+  if (!handle_) return;
+  auto* h = static_cast<HANDLE*>(handle_);
+  CloseHandle(*h);
+  delete h;
+}
+
+Expected<SessionCarrier> SessionCarrier::create(StringView root_session_id) {
+  std::string name =
+      "Local\\dd-session-ids-" + std::to_string(GetCurrentProcessId());
+  const std::string data{root_session_id};
+  DWORD size = static_cast<DWORD>(data.size());
+  HANDLE h = CreateFileMappingA(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE,
+                                0, size, name.c_str());
+  if (!h) {
+    return Error{Error::Code::OTHER, "CreateFileMapping failed"};
+  }
+  void* view = MapViewOfFile(h, FILE_MAP_WRITE, 0, 0, size);
+  if (view) {
+    std::memcpy(view, data.data(), data.size());
+    UnmapViewOfFile(view);
+  }
+  return SessionCarrier(new HANDLE{h});
+}
+
+Optional<std::string> read_inherited_session_id() {
+  DWORD ppid = get_parent_process_id();
+  if (!ppid) return nullopt;
+  std::string name = "Local\\dd-session-ids-" + std::to_string(ppid);
+  HANDLE h = OpenFileMappingA(FILE_MAP_READ, FALSE, name.c_str());
+  if (!h) return nullopt;
+  void* view = MapViewOfFile(h, FILE_MAP_READ, 0, 0, 0);
+  if (!view) {
+    CloseHandle(h);
+    return nullopt;
+  }
+  MEMORY_BASIC_INFORMATION mbi;
+  VirtualQuery(view, &mbi, sizeof(mbi));
+  const char* data = static_cast<const char*>(view);
+  std::string result(data, strnlen(data, mbi.RegionSize));
+  UnmapViewOfFile(view);
+  CloseHandle(h);
+  if (result.empty()) return nullopt;
+  return result;
+}
+
 InMemoryFile::InMemoryFile(void* handle) : handle_(handle) {}
 
 InMemoryFile::InMemoryFile(InMemoryFile&& rhs) {

src/datadog/tracer.cpp

@@ -66,6 +66,12 @@ Tracer::Tracer(const FinalizedTracerConfig& config,
       baggage_extraction_enabled_(false),
       tracing_enabled_(config.tracing_enabled),
       resource_renaming_mode_(config.resource_renaming_mode) {
+  // Create a shared memory carrier so exec'd children can inherit the root
+  // session ID without relying solely on environment variables.
+  if (auto carrier = SessionCarrier::create(signature_.root_session_id)) {
+    session_carrier_ = std::make_shared<SessionCarrier>(std::move(*carrier));
+  }
+  // Also set the env var for interop with SDKs that still use it.
   environment::set(environment::_DD_ROOT_CPP_SESSION_ID,
                    signature_.root_session_id);
 

src/datadog/tracer_config.cpp

@@ -407,8 +407,12 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
     final_config.runtime_id = user_config.runtime_id;
   }
 
-  if (auto val = lookup(environment::_DD_ROOT_CPP_SESSION_ID)) {
-    final_config.root_session_id = std::string{*val};
+  // Prefer shared memory carrier (set by a C++ parent); fall back to the
+  // environment variable for interop with SDKs that still use env vars.
+  if (auto shm = read_inherited_session_id()) {
+    final_config.root_session_id = std::move(*shm);
+  } else if (auto env = lookup(environment::_DD_ROOT_CPP_SESSION_ID)) {
+    final_config.root_session_id = std::string{*env};
   }
 
   final_config.process_tags = user_config.process_tags;