libdatadog 30.0.0.1.0 → 35.0.0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e50b7ba6d9c8d7502219ed0dd2ae3797e12bf551c4845ee4c8730af1d97062c
-  data.tar.gz: 9235838a689be504cd9ac83f6ef25835f8ea3005e624091986a04a9acadc2792
+  metadata.gz: ab0a20f1852ac415e905e178e09208b0986f3119d936a3f8f8326df8e0f778a1
+  data.tar.gz: aadd3917949f04607ba2be0ea20dff98349b5a14844b87b6dcd7508b40ec1fcf
 SHA512:
-  metadata.gz: a5d1929694a5bb8683592fc696270256c3002984ad1e6cd421896870a2f8522f68d811ca64028b34e9119c92aff9b545cedbb974270f1fc5a37b2eadaf3ae507
-  data.tar.gz: deaa3c844646f9037f4b7007a397b806b9c96515b3c2c8ce2d0b92240a12994863f710d9486b78c92383933176fa43b5799493f7dcaaf575cb26d3d347f50b6e
+  metadata.gz: 538303506ea439d8a62e885f65ca62df32d62d4482bd61984c261d47652d814517a7e379038876c57e4bf0e78c5da40981b666f37f83eec2bb9cb40303b029f0
+  data.tar.gz: 7859de5265189b8b2e5faaf8c7ec6c91a6fbd2d0bc482dec4de443f5362a8458f2ae15390c7d6947d78785b12dd6c0a09d3c70c3aca9e865d8e464534dc4f92c

data/lib/libdatadog/version.rb

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "etc"
+require "pathname"
+
+module BuildFromSource
+  module Target
+    # Mapping from Rust target triples to Ruby gem platform names.
+    # x86_64-apple-darwin is deliberately not supported.
+    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
+
+    class << self
+      def host_triple
+        @host_triple ||= begin
+          output = `rustc -vV`
+          raise "rustc not found or failed" unless $?.success?
+
+          triple = output[/^host:\s*(.+)$/, 1]
+          raise "Could not determine host triple from rustc output" unless triple
+
+          triple = triple.strip
+
+          triple
+        end
+      end
+
+      def ruby_platform(rust_triple = host_triple)
+        RUST_TO_RUBY.fetch(rust_triple) do
+          raise "Unsupported Rust target: #{rust_triple}. " \
+                "Supported: #{RUST_TO_RUBY.keys.join(", ")}"
+        end
+      end
+    end
+  end
+
+  module Paths
+    class << self
+      # Project root
+      def root
+        @root ||= (Pathname.new(__dir__) / "..").expand_path
+      end
+
+      # Intermediate build artifacts
+      def tmp
+        root / "tmp"
+      end
+
+      def builder_root
+        tmp / "builder"
+      end
+
+      def builder_bin
+        builder_root / "bin" / "release"
+      end
+
+      def cargo_target
+        tmp / "cargo-target"
+      end
+
+      def cmake_out
+        tmp / "cmake-out"
+      end
+
+      # Vendor output tree
+      def vendor
+        root / "vendor" / "libdatadog-#{Libdatadog::LIB_VERSION}"
+      end
+
+      def vendor_target(ruby_platform = Target.ruby_platform)
+        vendor / ruby_platform
+      end
+    end
+  end
+
+  module Builder
+    class << self
+      # Build the cargo install command for the builder crate's `release` binary.
+      #
+      # source:   optional path to a local libdatadog checkout
+      # features: optional comma-separated feature override
+      def cargo_install_cmd(source: nil, features: nil)
+        cmd = %W[cargo install --bin release --root #{Paths.builder_root} --force]
+
+        cmd += if source
+          ["--path", (Pathname.new(source).expand_path / "builder").to_s]
+        else
+          [
+            "--git", "https://github.com/DataDog/libdatadog",
+            "--tag", "v#{Libdatadog::LIB_VERSION}",
+            "builder"
+          ]
+        end
+
+        cmd += ["--no-default-features", "--features", features] if features
+
+        cmd
+      end
+
+      # Environment variables required by the builder binary at runtime.
+      #
+      # The builder reads PROFILE, TARGET, and CARGO_PKG_VERSION via env::var()
+      # (they are NOT baked in at compile time despite the build script's cargo:rustc-env).
+      # CARGO_TARGET_DIR is needed because we are not inside a cargo workspace.
+      # HOST, OUT_DIR, OPT_LEVEL, DEBUG, and NUM_JOBS are required by the cmake crate
+      # used internally to build the crashtracker receiver.
+      def env(host_triple)
+        {
+          "PROFILE" => "release",
+          "OPT_LEVEL" => "3",
+          "DEBUG" => "false",
+          "TARGET" => host_triple,
+          "HOST" => host_triple,
+          "CARGO_PKG_VERSION" => Libdatadog::LIB_VERSION,
+          "CARGO_TARGET_DIR" => Paths.cargo_target.to_s,
+          "OUT_DIR" => Paths.cmake_out.to_s,
+          "NUM_JOBS" => begin
+            Etc.nprocessors
+          rescue
+            1
+          end.to_s
+        }
+      end
+    end
+  end
+end
+
+namespace :libdatadog do
+  desc "Build libdatadog from source for the current platform"
+  task :build do
+    host_triple = BuildFromSource::Target.host_triple
+    ruby_platform = BuildFromSource::Target.ruby_platform(host_triple)
+    paths = BuildFromSource::Paths
+
+    # Install builder binary
+    source = ENV["LIBDATADOG_SOURCE"]
+    features = ENV["LIBDATADOG_FEATURES"]
+    install_cmd = BuildFromSource::Builder.cargo_install_cmd(source: source, features: features)
+
+    info = source ? "local: #{source}" : "v#{Libdatadog::LIB_VERSION}"
+    puts "Installing builder (#{info})..."
+    system(*install_cmd) || raise("Failed to install builder via cargo")
+
+    # Prepare output directories
+    target_dir = paths.vendor_target(ruby_platform)
+    [target_dir, paths.cargo_target, paths.cmake_out].each(&:mkpath)
+
+    # Invoke builder
+    env = BuildFromSource::Builder.env(host_triple)
+
+    puts "Building libdatadog for #{ruby_platform} (#{host_triple})"
+    puts "Output: #{target_dir}"
+    system(env, paths.builder_bin.to_s, "--out", target_dir.to_s) || raise("Builder failed")
+
+    # Fix file permissions to match expected values for packaging
+    Helpers.fix_file_permissions(target_dir.to_s)
+
+    puts "Done! Artifacts in #{target_dir}"
+  end
+
+  desc "Remove build intermediates and vendor tree"
+  task :clean do
+    [BuildFromSource::Paths.tmp, BuildFromSource::Paths.vendor].each do |dir|
+      if dir.exist?
+        puts "Removing #{dir}"
+        dir.rmtree
+      end
+    end
+  end
+end

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