libdatadog 33.0.0.1.0-aarch64-linux → 36.0.0.1.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de4a583daaad84afa2490571e9ad70bf8c43e5885d8ceab8d64f74a99b672e8c
-  data.tar.gz: 1df1b8bbf4e4552b6e347f4e6d5bfbab8db7eac141479542c4addcbb8ee204c5
+  metadata.gz: bfc07c766954c8b4e2cd4f37dfba1dc1fbf07b35630ba1e35e9fc551ac74151b
+  data.tar.gz: f99fe8ef633889cd373f9a8effcae6b970a1c2db9d6f015e912c766008ed4c26
 SHA512:
-  metadata.gz: e1f2da4bf10c28e377832e36235c1c63da18a65522a80fb5c11cd56baa7dbb0c670b6dfe7a30585d9f4a23fa6997229dde64a4cb9cff4d6aff46fffb11e1d939
-  data.tar.gz: ccbc74d62b10bd40023d7e1822de07f66f03ddd33e3e232cc60246f66404e6ae4c1a7165c2e5a706dff85c3219afd0b419d0ee0c1545702d5792be532fd49cff
+  metadata.gz: 0de5187e3b95619af4019749c077604c0663b0aecfa9cdee1e6bdba867c7e3ea210e04b7a4e6e933d68c9e7d2f2437c3d79205c865edd55d3ff517ebdd8aad88
+  data.tar.gz: 38e6cf06e5c6a54bae0894b30fbd8061f0901f87ead101bb70800d09aea08e0a9b527d372b93c81bdfea3fcd4aac0666e883dcca77de875fc17c62bbef015ae3

data/lib/libdatadog/version.rb

@@ -2,7 +2,7 @@
 
 module Libdatadog
   # Current libdatadog version
-  LIB_VERSION = "33.0.0"
+  LIB_VERSION = "36.0.0"
 
   GEM_MAJOR_VERSION = "1"
   GEM_MINOR_VERSION = "0"

data/libdatadog.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "libdatadog/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "libdatadog"
+  spec.version = Libdatadog::VERSION
+  spec.authors = ["Datadog, Inc."]
+  spec.email = ["dev@datadoghq.com"]
+
+  spec.summary = "Library of common code used by Datadog Continuous Profiler for Ruby"
+  spec.description =
+    "libdatadog is a Rust-based utility library for Datadog's ddtrace gem."
+  spec.homepage = "https://docs.datadoghq.com/tracing/"
+  spec.license = "Apache-2.0"
+  spec.required_ruby_version = ">= 2.5.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/datadog/libdatadog-rb"
+
+  # Require releases on rubygems.org to be coming from multi-factor-auth-authenticated accounts
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`
+      .split("\x0")
+      .reject do |f|
+        (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features|publish)/|\.(?:git|travis|circleci)|appveyor)})
+      end
+      .reject do |f|
+        [".rspec", ".standard.yml", "Rakefile", "docker-compose.yml", "Gemfile", "README.md", "CONTRIBUTING.md", "LICENSE-3rdparty.yml"].include?(f)
+      end
+      .reject { |f| f.end_with?(".tar.gz") }
+      .reject { |f| f.end_with?(".nix") || f.start_with?("flake.") }
+  end
+  spec.require_paths = ["lib"]
+end

data/rust-toolchain.toml

@@ -0,0 +1,6 @@
+[toolchain]
+# Rust toolchain used to build libdatadog from source. Keep the channel in sync
+# with the libdatadog `rust-toolchain.toml` for the LIB_VERSION being packaged
+# and with the CI `RUST_VERSION` in .github/workflows/build.yml.
+channel = "1.87.0"
+profile = "minimal"

data/tasks/build.rake

@@ -10,8 +10,10 @@ module BuildFromSource
     RUST_TO_RUBY = {
       "x86_64-unknown-linux-gnu" => "x86_64-linux",
       "x86_64-unknown-linux-musl" => "x86_64-linux-musl",
+      "x86_64-alpine-linux-musl" => "x86_64-linux-musl",
       "aarch64-unknown-linux-gnu" => "aarch64-linux",
       "aarch64-unknown-linux-musl" => "aarch64-linux-musl",
+      "aarch64-alpine-linux-musl" => "aarch64-linux-musl",
       "aarch64-apple-darwin" => "arm64-darwin"
     }.freeze
 

data/tasks/gem.rake

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "rubygems/package"
+require "rubygems/package/tar_reader"
+require "zlib"
+require "stringio"
+
+# Builds .gem packages from vendored libdatadog artifacts.
+#
+# Intentionally duplicates some Rakefile logic so both can coexist during
+# the migration; the Rakefile originals will be removed once the new tasks
+# are fully adopted.
+module GemPackaging
+  module Platform
+    # Mapping from gem platform names to the vendor platform directories
+    # included in that gem.  We bundle glibc and musl variants together
+    # for Linux to work around https://github.com/rubygems/rubygems/issues/3174
+    GEM_TO_VENDOR = {
+      "x86_64-linux" => ["x86_64-linux", "x86_64-linux-musl"],
+      "aarch64-linux" => ["aarch64-linux", "aarch64-linux-musl"],
+      "arm64-darwin" => ["arm64-darwin"]
+    }.freeze
+
+    ALL_VENDOR = GEM_TO_VENDOR.values.flatten.freeze
+
+    class << self
+      # Resolve a RUBY_PLATFORM string (or gem platform name) to a known
+      # gem platform key.
+      #
+      #   resolve("x86_64-linux")      #=> "x86_64-linux"
+      #   resolve("x86_64-linux-musl") #=> "x86_64-linux"
+      #   resolve("arm64-darwin24")    #=> "arm64-darwin"
+      def resolve(platform_string)
+        return platform_string if GEM_TO_VENDOR.key?(platform_string)
+
+        # musl suffix (x86_64-linux-musl -> x86_64-linux)
+        without_musl = platform_string.sub(/-musl\z/, "")
+        return without_musl if GEM_TO_VENDOR.key?(without_musl)
+
+        # macOS Darwin version suffix (arm64-darwin24 -> arm64-darwin)
+        GEM_TO_VENDOR.each_key do |gp|
+          return gp if platform_string.start_with?(gp)
+        end
+
+        raise "Could not resolve platform '#{platform_string}' to a supported gem platform. " \
+              "Supported: #{GEM_TO_VENDOR.keys.join(", ")}, ruby"
+      end
+
+      # Vendor platform directories needed for a given gem platform.
+      def vendor_platforms(gem_platform)
+        if gem_platform == "ruby"
+          ALL_VENDOR
+        else
+          GEM_TO_VENDOR.fetch(gem_platform) do
+            raise "Unknown gem platform: #{gem_platform}. " \
+                  "Supported: #{GEM_TO_VENDOR.keys.join(", ")}, ruby"
+          end
+        end
+      end
+    end
+  end
+
+  module Paths
+    class << self
+      # Project root
+      def root
+        @root ||= (Pathname.new(__dir__) / "..").expand_path
+      end
+
+      # Vendor tree for the current library version
+      def vendor
+        root / "vendor" / "libdatadog-#{Libdatadog::LIB_VERSION}"
+      end
+
+      # Vendor directory for a specific platform
+      def vendor_platform(name)
+        vendor / name
+      end
+
+      # Output directory for built gems
+      def pkg
+        root / "pkg"
+      end
+
+      # The gemspec file
+      def gemspec
+        root / "libdatadog.gemspec"
+      end
+
+      # Expected .gem filename for a given gem platform
+      def gem_file_name(gem_platform)
+        spec = Gem::Specification.new do |s|
+          s.name = "libdatadog"
+          s.version = Libdatadog::VERSION
+          s.platform = gem_platform unless gem_platform == "ruby"
+        end
+        spec.file_name
+      end
+
+      # Full path to the .gem for a given gem platform
+      def gem(gem_platform)
+        pkg / gem_file_name(gem_platform)
+      end
+    end
+  end
+
+  module Packager
+    # Files that must have executable permissions (0755); everything else gets 0644.
+    EXECUTABLE_FILES = %w[
+      libdatadog-crashtracking-receiver
+      libdatadog_profiling.so
+      libdatadog_profiling.dylib
+    ].freeze
+
+    # Vendored files excluded from gems (not needed at runtime).
+    EXCLUDED_FILES = %w[
+      datadog_profiling.pc
+      libdatadog_profiling.a
+      datadog_profiling-static.pc
+      libdatadog_profiling.debug
+      DatadogConfig.cmake
+    ].freeze
+
+    class << self
+      # Collect vendored files for one or more vendor platform directories,
+      # filtering out tarballs and files not needed at runtime.
+      # Returns paths relative to the project root (what gemspec.files expects).
+      def vendor_files(*vendor_platforms)
+        vendor_platforms.flat_map { |vp|
+          Paths.vendor_platform(vp).glob("**/*")
+            .select(&:file?)
+            .map { |p| p.relative_path_from(Paths.root).to_s }
+            .reject { |p| p.end_with?(".tar.gz") }
+            .reject { |p| EXCLUDED_FILES.include?(File.basename(p)) }
+        }
+      end
+
+      # Verify that required vendor directories exist and contain files.
+      def check_vendor!(*vendor_platforms)
+        missing = vendor_platforms.reject { |vp|
+          dir = Paths.vendor_platform(vp)
+          dir.exist? && dir.glob("**/*").any?(&:file?)
+        }
+
+        return if missing.empty?
+
+        raise "Missing vendor artifacts for: #{missing.join(", ")}. " \
+              "Expected under #{Paths.vendor}/. " \
+              "Run `rake libdatadog:build` or download vendor artifacts first."
+      end
+
+      # Build a single .gem into pkg/.
+      def build_gem(gem_platform:, vendor_platforms:)
+        check_vendor!(*vendor_platforms)
+
+        spec = eval(Paths.gemspec.read, nil, Paths.gemspec.to_s) # standard:disable Security/Eval
+        spec.files += vendor_files(*vendor_platforms)
+        spec.platform = gem_platform unless gem_platform == "ruby"
+
+        Paths.pkg.mkpath
+
+        puts "Building gem for platform=#{gem_platform} including: (this can take a while)"
+        pp spec.files.select { |f| f.start_with?("vendor/") }
+
+        Gem::Package.build(spec)
+        # build creates the .gem in cwd; move it into pkg/
+        gem_path = Paths.gem(gem_platform)
+        Pathname.new(spec.file_name).rename(gem_path)
+        puts("-" * 80)
+
+        gem_path
+      end
+
+      # Inspect the built .gem and raise on unexpected file permissions.
+      def validate_permissions!(gem_path)
+        puts "Validating permissions in #{gem_path}..."
+
+        Gem::Package::TarReader.new(gem_path.open("rb")) do |tar|
+          data_entry = tar.find { |entry| entry.header.name == "data.tar.gz" }
+          next unless data_entry
+
+          Gem::Package::TarReader.new(Zlib::GzipReader.new(StringIO.new(data_entry.read))) do |data_tar|
+            data_tar.each do |entry|
+              next if entry.directory?
+
+              filename = File.basename(entry.header.name)
+              actual = entry.header.mode.to_s(8)[-3..-1]
+              expected = EXECUTABLE_FILES.include?(filename) ? "755" : "644"
+
+              next if actual == expected
+
+              raise "Bad permissions for #{filename} in #{gem_path}: " \
+                    "got #{actual}, expected #{expected}"
+            end
+          end
+        end
+
+        puts "Permissions OK."
+      end
+
+      # Package a single gem platform (a GEM_TO_VENDOR key, or "ruby").
+      def package(platform)
+        if Platform::GEM_TO_VENDOR.key?(platform) || platform == "ruby"
+          build_gem(
+            gem_platform: platform,
+            vendor_platforms: Platform.vendor_platforms(platform)
+          )
+        else
+          resolved = Platform.resolve(platform)
+          puts "Resolved '#{platform}' -> gem platform '#{resolved}'"
+          package(resolved)
+        end
+      end
+
+      # Package every supported binary gem platform plus the ruby fallback gem.
+      def package_all
+        Platform::GEM_TO_VENDOR.each_key { |gp| package(gp) }
+        package("ruby")
+      end
+    end
+  end
+end
+
+namespace :gem do
+  desc "Package gem(s). No argument: all platforms + ruby. " \
+       "With argument: a specific gem platform, 'ruby', or a RUBY_PLATFORM value.\n" \
+       "  Examples: rake gem:package                    # all\n" \
+       "            rake gem:package[x86_64-linux]      # one binary platform\n" \
+       "            rake gem:package[ruby]              # ruby platform gem\n" \
+       "            rake gem:package[arm64-darwin24]    # resolved to arm64-darwin"
+  task :package, [:platform] do |_t, args|
+    platform = args[:platform]
+
+    if platform.nil? || platform.strip.empty?
+      GemPackaging::Packager.package_all
+    else
+      GemPackaging::Packager.package(platform)
+    end
+  end
+
+  desc "Validate file permissions in all gems under pkg/"
+  task :validate do
+    gems = GemPackaging::Paths.pkg.glob("*.gem")
+    raise "No .gem files found in #{GemPackaging::Paths.pkg}" if gems.empty?
+
+    gems.each { |gem_path| GemPackaging::Packager.validate_permissions!(gem_path) }
+  end
+end

data/vendor/{libdatadog-33.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-36.0.0/aarch64-linux}/LICENSE-3rdparty.csv

@@ -229,6 +229,7 @@ linux-raw-sys,https://github.com/sunfishcode/linux-raw-sys,Apache-2.0 WITH LLVM-
 litemap,https://github.com/unicode-org/icu4x,Unicode-3.0,The ICU4X Project Developers
 lock_api,https://github.com/Amanieu/parking_lot,MIT OR Apache-2.0,Amanieu d'Antras <amanieu@gmail.com>
 log,https://github.com/rust-lang/log,MIT OR Apache-2.0,The Rust Project Developers
+lru,https://github.com/jeromefroe/lru-rs,MIT,Jerome Froelich <jeromefroelic@hotmail.com>
 manual_future,https://github.com/dmarcuse/manual_future,MIT,Dominic Marcuse <dominic@marcuse.us>
 matchers,https://github.com/hawkw/matchers,MIT,Eliza Weisman <eliza@buoyant.io>
 matchit,https://github.com/ibraheemdev/matchit,MIT AND BSD-3-Clause,Ibraheem Ahmed <ibraheem@ibraheem.ca>
@@ -304,6 +305,7 @@ proc-macro-crate,https://github.com/bkchr/proc-macro-crate,MIT OR Apache-2.0,Bas
 proc-macro-error,https://gitlab.com/CreepySkeleton/proc-macro-error,MIT OR Apache-2.0,CreepySkeleton <creepy-skeleton@yandex.ru>
 proc-macro-error-attr,https://gitlab.com/CreepySkeleton/proc-macro-error,MIT OR Apache-2.0,CreepySkeleton <creepy-skeleton@yandex.ru>
 proc-macro2,https://github.com/dtolnay/proc-macro2,MIT OR Apache-2.0,"David Tolnay <dtolnay@gmail.com>, Alex Crichton <alex@alexcrichton.com>"
+proc-macro2-diagnostics,https://github.com/SergioBenitez/proc-macro2-diagnostics,MIT OR Apache-2.0,Sergio Benitez <sb@sergio.bz>
 prost,https://github.com/tokio-rs/prost,Apache-2.0,"Dan Burkert <dan@danburkert.com>, Lucio Franco <luciofranco14@gmail.com>, Casper Meijn <casper@meijn.net>, Tokio Contributors <team@tokio.rs>"
 prost-derive,https://github.com/tokio-rs/prost,Apache-2.0,"Dan Burkert <dan@danburkert.com>, Lucio Franco <luciofranco14@gmail.com>, Casper Meijn <casper@meijn.net>, Tokio Contributors <team@tokio.rs>"
 prost-types,https://github.com/tokio-rs/prost,Apache-2.0,"Dan Burkert <dan@danburkert.com>, Lucio Franco <luciofranco14@gmail.com>, Casper Meijn <casper@meijn.net>, Tokio Contributors <team@tokio.rs>"
@@ -427,6 +429,7 @@ target-triple,https://github.com/dtolnay/target-triple,MIT OR Apache-2.0,David T
 tempfile,https://github.com/Stebalien/tempfile,MIT OR Apache-2.0,"Steven Allen <steven@stebalien.com>, The Rust Project Developers, Ashley Mannix <ashleymannix@live.com.au>, Jason White <me@jasonwhite.io>"
 termcolor,https://github.com/BurntSushi/termcolor,Unlicense OR MIT,Andrew Gallant <jamslam@gmail.com>
 test-case-macros,https://github.com/frondeus/test-case,MIT,"Marcin Sas-Szymanski <marcin.sas-szymanski@anixe.pl>, Wojciech Polak <frondeus@gmail.com>, Łukasz Biel <lukasz.p.biel@gmail.com>"
+thin-vec,https://github.com/mozilla/thin-vec,MIT OR Apache-2.0,Aria Beingessner <a.beingessner@gmail.com>
 thiserror,https://github.com/dtolnay/thiserror,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 thiserror-impl,https://github.com/dtolnay/thiserror,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 thread_local,https://github.com/Amanieu/thread_local-rs,MIT OR Apache-2.0,Amanieu d'Antras <amanieu@gmail.com>

data/vendor/{libdatadog-33.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu → libdatadog-36.0.0/aarch64-linux}/include/datadog/common.h

@@ -1624,6 +1624,9 @@ typedef struct ddog_ContextKey {
 } ddog_ContextKey;
 
 typedef struct ddog_TraceExporter ddog_TraceExporter;
+typedef struct ddog_TracerSpan ddog_TracerSpan;
+typedef struct ddog_TracerTraceChunks ddog_TracerTraceChunks;
+typedef struct ddog_TraceExporterCancelToken ddog_TraceExporterCancelToken;
 
 
 /**
@@ -1669,9 +1672,12 @@ typedef struct ddog_TraceExporterResponse ddog_TraceExporterResponse;
 /**
  * A shared runtime that manages PausableWorkers and provides fork safety hooks.
  *
- * The SharedRuntime owns a tokio runtime and tracks PausableWorkers spawned on it.
- * It provides methods to safely pause workers before forking and restart them
- * after fork in both parent and child processes.
+ * The SharedRuntime owns a tokio runtime (on native) and tracks PausableWorkers
+ * spawned on it. It provides methods to safely pause workers before forking and
+ * restart them after fork in both parent and child processes.
+ *
+ * On wasm32, no tokio runtime is created. Workers are spawned via `spawn_local`
+ * on the JS event loop.
  *
  * # Mutex lock order
  * When locking both [Self::runtime] and [Self::workers], the mutex must be locked in the order of
@@ -1730,6 +1736,26 @@ typedef struct ddog_TelemetryClientConfig {
   ddog_CharSlice parent_session_id;
 } ddog_TelemetryClientConfig;
 
+/**
+ * FFI-safe bundle of scalar fields for creating a [`TracerSpan`].
+ *
+ * Passed by reference to [`ddog_tracer_span_new`] so that adding or
+ * changing fields does not break the function signature.
+ */
+typedef struct ddog_TracerSpanFields {
+  ddog_CharSlice service;
+  ddog_CharSlice name;
+  ddog_CharSlice resource;
+  ddog_CharSlice span_type;
+  uint64_t trace_id_low;
+  uint64_t trace_id_high;
+  uint64_t span_id;
+  uint64_t parent_id;
+  int64_t start;
+  int64_t duration;
+  int32_t error;
+} ddog_TracerSpanFields;
+
 typedef enum ddog_LibraryConfigSource {
   DDOG_LIBRARY_CONFIG_SOURCE_LOCAL_STABLE_CONFIG = 0,
   DDOG_LIBRARY_CONFIG_SOURCE_FLEET_STABLE_CONFIG = 1,
@@ -2207,6 +2233,52 @@ typedef struct ddog_ffe_AttributePair {
   struct ddog_ffe_AttributeValue value;
 } ddog_ffe_AttributePair;
 
+/**
+ * Error codes for SharedRuntime FFI operations.
+ */
+typedef enum ddog_SharedRuntimeErrorCode {
+  /**
+   * Invalid argument provided (e.g. null handle).
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_INVALID_ARGUMENT,
+  /**
+   * The runtime is not available or in an invalid state.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_RUNTIME_UNAVAILABLE,
+  /**
+   * Failed to acquire a lock on internal state.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_LOCK_FAILED,
+  /**
+   * A worker operation failed.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_WORKER_ERROR,
+  /**
+   * Failed to create the tokio runtime.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_RUNTIME_CREATION,
+  /**
+   * Shutdown timed out.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_SHUTDOWN_TIMED_OUT,
+  /**
+   * An unexpected panic occurred inside the FFI call.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_PANIC,
+} ddog_SharedRuntimeErrorCode;
+
+/**
+ * Error returned by SharedRuntime FFI functions.
+ */
+typedef struct ddog_SharedRuntimeFFIError {
+  enum ddog_SharedRuntimeErrorCode code;
+  /**
+   * The error message is always defined when the error is returned by a ddog_shared_runtime
+   * ffi.
+   */
+  char *msg;
+} ddog_SharedRuntimeFFIError;
+
 typedef enum ddog_crasht_BuildIdType {
   DDOG_CRASHT_BUILD_ID_TYPE_GNU,
   DDOG_CRASHT_BUILD_ID_TYPE_GO,

data/vendor/{libdatadog-33.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-36.0.0/aarch64-linux}/include/datadog/crashtracker.h

@@ -170,6 +170,25 @@ struct ddog_VoidResult ddog_crasht_report_unhandled_exception(ddog_CharSlice err
                                                               ddog_CharSlice error_message,
                                                               struct ddog_crasht_Handle_StackTrace *runtime_stack);
 
+/**
+ * Register the expected PID of the socket-based crash receiver
+ *
+ * When `collect_all_threads` is enabled and the receiver is reached via a Unix
+ * socket, the crash handler will only grant ptrace permission if the socket
+ * peer's PID matches this registered value.
+ *
+ * Call this after establishing a trusted connection to the sidecar
+ *
+ * # Safety
+ *   This function is safe to call from any thread at any time.
+ */
+void ddog_crasht_set_expected_receiver_pid(int32_t pid);
+
+/**
+ * Returns the currently registered expected receiver PID, or 0 if unset.
+ */
+int32_t ddog_crasht_get_expected_receiver_pid(void);
+
 /**
  * Removes all existing additional tags
  * Expected to be used after a fork, to reset the additional tags on the child