libdatadog 33.0.0.1.0 → 35.0.0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae787649f269d3e1f8bcf40292418ea3670c7f383dc41fd639727b6775c9cfd2
-  data.tar.gz: d17b4519ac50c44ccb13f8260dd0d837c992ebd9dcb759e0e4f3d0b84e0929a8
+  metadata.gz: ab0a20f1852ac415e905e178e09208b0986f3119d936a3f8f8326df8e0f778a1
+  data.tar.gz: aadd3917949f04607ba2be0ea20dff98349b5a14844b87b6dcd7508b40ec1fcf
 SHA512:
-  metadata.gz: 89468c6b64dd75f9ab5c44bf9177ca508d962f555e4e096388ee4a187dd9a880baa81b18e392ed23e8402e48d1a09bf256e83b00d6995538d2d56ac155336bf5
-  data.tar.gz: 570a8af64dd4052b7abec6ccb6c62b8a7219fa44f920ca3189157991bf04160c6579e43c6b32df27ad5a399e323e30d922c454aa5da9893ab57a1561c0e80cf5
+  metadata.gz: 538303506ea439d8a62e885f65ca62df32d62d4482bd61984c261d47652d814517a7e379038876c57e4bf0e78c5da40981b666f37f83eec2bb9cb40303b029f0
+  data.tar.gz: 7859de5265189b8b2e5faaf8c7ec6c91a6fbd2d0bc482dec4de443f5362a8458f2ae15390c7d6947d78785b12dd6c0a09d3c70c3aca9e865d8e464534dc4f92c

data/lib/libdatadog/version.rb

@@ -2,7 +2,7 @@
 
 module Libdatadog
   # Current libdatadog version
-  LIB_VERSION = "33.0.0"
+  LIB_VERSION = "35.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-35.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>"

data/vendor/{libdatadog-33.0.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-35.0.0/aarch64-linux}/include/datadog/common.h

@@ -1624,6 +1624,8 @@ typedef struct ddog_ContextKey {
 } ddog_ContextKey;
 
 typedef struct ddog_TraceExporter ddog_TraceExporter;
+typedef struct ddog_TracerSpan ddog_TracerSpan;
+typedef struct ddog_TracerTraceChunks ddog_TracerTraceChunks;
 
 
 /**
@@ -1669,9 +1671,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 +1735,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,

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

@@ -21,11 +21,11 @@ extern "C" {
 void ddog_trace_exporter_error_free(struct ddog_TraceExporterError *error);
 
 /**
- * Return a read-only pointer to the response body. This pointer is only valid as long as
- * `response` is valid.
+ * Return a borrowed view of the response body.  The returned slice is
+ * only valid as long as `response` is alive.  Returns an empty slice
+ * when `response` is null or the body is absent.
  */
-const uint8_t *ddog_trace_exporter_response_get_body(const struct ddog_TraceExporterResponse *response,
-                                                     uintptr_t *out_len);
+ddog_ByteSlice ddog_trace_exporter_response_get_body(const struct ddog_TraceExporterResponse *response);
 
 /**
  * Free `response` and all its contents. After being called response will not point to a valid
@@ -209,6 +209,139 @@ struct ddog_TraceExporterError *ddog_trace_exporter_send(const ddog_TraceExporte
                                                          ddog_ByteSlice trace,
                                                          struct ddog_TraceExporterResponse **response_out);
 
+/**
+ * Create a new span with all scalar fields set.
+ *
+ * String fields are copied from the provided slices.  The `meta` and
+ * `metrics` maps start empty; use [`ddog_tracer_span_set_meta`] and
+ * [`ddog_tracer_span_set_metric`] to populate them.
+ *
+ * # Safety
+ *
+ * `out_handle` must point to valid, writable memory for a `Box<TracerSpan>`.
+ * All `CharSlice` fields in `fields` must point to valid memory for their
+ * stated length.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_new(ddog_TracerSpan **out_handle,
+                                                     const struct ddog_TracerSpanFields *fields);
+
+/**
+ * Free a `TracerSpan` and all its contents.
+ *
+ * After this call the handle is invalid and must not be reused.
+ *
+ * # Safety
+ *
+ * `handle` must have been created by [`ddog_tracer_span_new`] and must not
+ * be used after this call.
+ */
+void ddog_tracer_span_free(ddog_TracerSpan *handle);
+
+/**
+ * Add or overwrite a string tag (`meta`) on the span.
+ *
+ * Both `key` and `value` are copied into the span.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`.
+ * `key` and `value` must point to valid UTF-8 memory.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_meta(ddog_TracerSpan *handle,
+                                                          ddog_CharSlice key,
+                                                          ddog_CharSlice value);
+
+/**
+ * Add or overwrite a numeric tag (`metric`) on the span.
+ *
+ * The `key` is copied into the span.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`.
+ * `key` must point to valid UTF-8 memory.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_metric(ddog_TracerSpan *handle,
+                                                            ddog_CharSlice key,
+                                                            double value);
+
+/**
+ * Create a new empty trace chunks container.
+ *
+ * `capacity` is a hint for the expected number of chunks; pass 0 if
+ * unknown.
+ *
+ * # Safety
+ *
+ * `out_handle` must point to valid, writable memory for a
+ * `Box<TracerTraceChunks>`.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_new(uintptr_t capacity,
+                                                             ddog_TracerTraceChunks **out_handle);
+
+/**
+ * Free a trace chunks container and all its contents.
+ *
+ * After this call the handle is invalid and must not be reused.
+ *
+ * # Safety
+ *
+ * `handle` must have been created by [`ddog_tracer_trace_chunks_new`].
+ */
+void ddog_tracer_trace_chunks_free(ddog_TracerTraceChunks *handle);
+
+/**
+ * Start a new chunk (trace) inside the container.
+ *
+ * Subsequent [`ddog_tracer_trace_chunks_push_span`] calls will append
+ * spans to this chunk until the next `begin_chunk` call.
+ *
+ * `capacity` is a hint for the expected number of spans in this chunk;
+ * pass 0 if unknown.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerTraceChunks`.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_begin_chunk(ddog_TracerTraceChunks *handle,
+                                                                     uintptr_t capacity);
+
+/**
+ * Move a span into the current (last) chunk, consuming the span handle.
+ *
+ * A chunk must have been started with
+ * [`ddog_tracer_trace_chunks_begin_chunk`] before calling this function.
+ *
+ * # Safety
+ *
+ * * `handle` must be a valid pointer to a `TracerTraceChunks`.
+ * * `span` is consumed and must not be used after this call.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_push_span(ddog_TracerTraceChunks *handle,
+                                                                   ddog_TracerSpan *span);
+
+/**
+ * Send trace chunks through a [`TraceExporter`], consuming the chunks.
+ *
+ * This calls `TraceExporter::send_trace_chunks` which processes stats,
+ * serializes in the configured output format, and sends to the agent
+ * with retry logic.
+ *
+ * On success, if `response_out` is non-null, a heap-allocated
+ * [`ExporterResponse`] is written there.  The caller owns it and must
+ * free it with `ddog_trace_exporter_response_free`.
+ *
+ * # Safety
+ *
+ * * `exporter` must be a valid `TraceExporter` pointer.
+ * * `chunks` is consumed and must not be used after this call.
+ * * If `response_out` is non-null it must point to valid writable memory for a
+ *   `Box<ExporterResponse>`.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_send_trace_chunks(const ddog_TraceExporter *exporter,
+                                                                      ddog_TracerTraceChunks *chunks,
+                                                                      struct ddog_TraceExporterResponse **response_out);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

data/vendor/{libdatadog-33.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu → libdatadog-35.0.0/aarch64-linux}/lib/pkgconfig/datadog_profiling_with_rpath.pc

@@ -8,7 +8,7 @@ includedir=${prefix}/include
 
 Name: datadog_profiling
 Description: Contains common code used to implement Datadog's Continuous Profilers. (Dynamic linking variant, sets rpath)
-Version: 33.0.0
+Version: 35.0.0
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private:

data/vendor/{libdatadog-33.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu → libdatadog-35.0.0/aarch64-linux-musl}/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>"

data/vendor/{libdatadog-33.0.0/arm64-darwin/libdatadog-aarch64-apple-darwin → libdatadog-35.0.0/aarch64-linux-musl}/include/datadog/common.h

@@ -1624,6 +1624,8 @@ typedef struct ddog_ContextKey {
 } ddog_ContextKey;
 
 typedef struct ddog_TraceExporter ddog_TraceExporter;
+typedef struct ddog_TracerSpan ddog_TracerSpan;
+typedef struct ddog_TracerTraceChunks ddog_TracerTraceChunks;
 
 
 /**
@@ -1669,9 +1671,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 +1735,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,