ddtrace 1.1.0 → 1.12.1

data/lib/datadog/appsec/contrib/configuration/settings.rb

@@ -1,20 +0,0 @@
-# typed: false
-
-require 'datadog/core/configuration/base'
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Configuration
-        # Common settings for all integrations
-        # TODO: move to datadog/appsec/configuration or remove?
-        class Settings
-          include Datadog::Core::Configuration::Base
-
-          option :enabled, default: true
-          option :service_name
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/contrib/rack/configuration/settings.rb

@@ -1,22 +0,0 @@
-# typed: false
-
-require 'datadog/appsec/contrib/configuration/settings'
-require 'datadog/appsec/contrib/rack/ext'
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Rack
-        module Configuration
-          # Custom settings for the Rack integration
-          class Settings < Datadog::AppSec::Contrib::Configuration::Settings
-            option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/contrib/rack/request.rb

@@ -1,58 +0,0 @@
-# typed: true
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Rack
-        # Normalized extration of data from Rack::Request
-        module Request
-          def self.query(request)
-            # Downstream libddwaf expects keys and values to be extractable
-            # separately so we can't use [[k, v], ...]. We also want to allow
-            # duplicate keys, so we use [{k, v}, ...] instead.
-            request.query_string.split('&').map do |e|
-              k, v = e.split('=').map { |s| CGI.unescape(s) }
-
-              { k => v }
-            end
-          end
-
-          # Rack < 2.0 does not have :each_header
-          # TODO: We need access to Rack here. We must make sure we are able to load AppSec without Rack,
-          # TODO: while still ensure correctness in ths code path.
-          if defined?(::Rack) && ::Rack::Request.instance_methods.include?(:each_header)
-            def self.headers(request)
-              request.each_header.each_with_object({}) do |(k, v), h|
-                h[k.gsub(/^HTTP_/, '').downcase.tr('_', '-')] = v if k =~ /^HTTP_/
-              end
-            end
-          else
-            def self.headers(request)
-              request.env.each_with_object({}) do |(k, v), h|
-                h[k.gsub(/^HTTP_/, '').downcase.tr('_', '-')] = v if k =~ /^HTTP_/
-              end
-            end
-          end
-
-          def self.body(request)
-            request.body.read.tap { request.body.rewind }
-          end
-
-          def self.url(request)
-            request.url
-          end
-
-          def self.cookies(request)
-            request.cookies
-          end
-
-          def self.form_hash(request)
-            # usually Hash<String,String> but can be a more complex
-            # Hash<String,String||Array||Hash> when e.g coming from JSON
-            request.env['rack.request.form_hash']
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/contrib/rack/response.rb

@@ -1,24 +0,0 @@
-# typed: true
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Rack
-        # Normalized extration of data from Rack::Response
-        module Response
-          def self.headers(response)
-            response.headers.each_with_object({}) { |(k, v), h| h[k.downcase] = v }
-          end
-
-          def self.cookies(response)
-            response.cookies
-          end
-
-          def self.status(response)
-            response.status
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/contrib/rails/configuration/settings.rb

@@ -1,22 +0,0 @@
-# typed: false
-
-require 'datadog/appsec/contrib/configuration/settings'
-require 'datadog/appsec/contrib/rails/ext'
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Rails
-        module Configuration
-          # Custom settings for the Rack integration
-          class Settings < Datadog::AppSec::Contrib::Configuration::Settings
-            option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/contrib/sinatra/configuration/settings.rb

@@ -1,22 +0,0 @@
-# typed: false
-
-require 'datadog/appsec/contrib/configuration/settings'
-require 'datadog/appsec/contrib/sinatra/ext'
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Sinatra
-        module Configuration
-          # Custom settings for the Rack integration
-          class Settings < Datadog::AppSec::Contrib::Configuration::Settings
-            option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/recorder.rb

@@ -1,117 +0,0 @@
-# typed: true
-
-require 'datadog/profiling/buffer'
-require 'datadog/profiling/flush'
-
-module Datadog
-  module Profiling
-    # Stores profiling events gathered by `Collector`s
-    class Recorder
-      attr_reader :max_size
-
-      # TODO: Why does the Recorder directly reference the `code_provenance_collector`?
-      #
-      # For starters, this is weird/a problem because the relationship is supposed to go in the other direction:
-      # collectors are supposed to record their results in the `Recorder`, rather than the `Recorder` having to know
-      # about individual collectors.
-      #
-      # But the `code_provenance_collector` is different from other existing and potential collectors because it is not
-      # asynchronous. It does not gather data over time and record it as it goes. Instead, you call it once per profile,
-      # synchronously, and just use what it spits out.
-      #
-      # The current design of the `Recorder` is quite tied to the asynchronous model. Modifying our current design
-      # to support synchronous collectors is non-trivial, and I decided not to go through with it because we're
-      # soon going to replace the `Recorder` and many other existing classes with a
-      # [libddprof](https://github.com/datadog/libddprof)-based implementation, and thus I don't think massive refactors
-      # are worth it before moving to libddprof.
-
-      def initialize(event_classes, max_size, code_provenance_collector:, last_flush_time: Time.now.utc)
-        @buffers = {}
-        @last_flush_time = last_flush_time
-        @max_size = max_size
-        @code_provenance_collector = code_provenance_collector
-
-        # Add a buffer for each class
-        event_classes.each do |event_class|
-          @buffers[event_class] = Profiling::Buffer.new(max_size)
-        end
-
-        # Event classes can only be added ahead of time
-        @buffers.freeze
-      end
-
-      def [](event_class)
-        @buffers[event_class]
-      end
-
-      def push(events)
-        if events.is_a?(Array)
-          # Push multiple events
-          event_class = events.first.class
-          raise UnknownEventError, event_class unless @buffers.key?(event_class)
-
-          @buffers[event_class].concat(events)
-        else
-          # Push single event
-          event_class = events.class
-          raise UnknownEventError, event_class unless @buffers.key?(event_class)
-
-          @buffers[event_class].push(events)
-        end
-      end
-
-      def flush
-        event_count = 0
-
-        event_groups, start, finish = update_time do
-          @buffers.collect do |event_class, buffer|
-            events = buffer.pop
-            next if events.empty?
-
-            event_count += events.length
-            EventGroup.new(event_class, events)
-          end.compact
-        end
-
-        code_provenance = @code_provenance_collector.refresh.generate_json if @code_provenance_collector
-
-        OldFlush.new(
-          start: start,
-          finish: finish,
-          event_groups: event_groups,
-          event_count: event_count,
-          code_provenance: code_provenance,
-        )
-      end
-
-      # NOTE: Remember that if the recorder is being accessed by multiple threads, this is an inherently racy operation.
-      def empty?
-        @buffers.values.all?(&:empty?)
-      end
-
-      # Error when event of an unknown type is used with the Recorder
-      class UnknownEventError < StandardError
-        attr_reader :event_class
-
-        def initialize(event_class)
-          @event_class = event_class
-        end
-
-        def message
-          @message ||= "Unknown event class '#{event_class}' for profiling recorder."
-        end
-      end
-
-      private
-
-      def update_time
-        start = @last_flush_time
-        result = yield
-        @last_flush_time = Time.now.utc
-
-        # Return event groups, start time, finish time
-        [result, start, @last_flush_time]
-      end
-    end
-  end
-end

data/lib/datadog/profiling/transport/client.rb

@@ -1,16 +0,0 @@
-# typed: true
-
-module Datadog
-  module Profiling
-    module Transport
-      # Generic interface for profiling transports
-      module Client
-        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-
-        def send_profiling_flush(flush)
-          raise NotImplementedError
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/transport/http/api/endpoint.rb

@@ -1,107 +0,0 @@
-# typed: true
-
-require 'datadog/core/utils/compression'
-require 'datadog/core/vendor/multipart-post/multipart/post/composite_read_io'
-require 'datadog/profiling/ext'
-require 'datadog/profiling/transport/http/response'
-require 'ddtrace/transport/http/api/endpoint'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        module API
-          # Datadog API endpoint for profiling
-          class Endpoint < Datadog::Transport::HTTP::API::Endpoint
-            include Profiling::Ext::Transport::HTTP
-
-            # These tags are read from the flush object (see below) directly and so we ignore any extra copies that
-            # may come in the tags hash to avoid duplicates.
-            TAGS_TO_IGNORE_IN_TAGS_HASH = %w[service env version].freeze
-            private_constant :TAGS_TO_IGNORE_IN_TAGS_HASH
-
-            attr_reader \
-              :encoder
-
-            def initialize(path, encoder)
-              super(:post, path)
-              @encoder = encoder
-            end
-
-            def call(env, &block)
-              # Build request
-              env.form = build_form(env)
-
-              # Send request
-              http_response = super(env, &block)
-
-              # Build response
-              Profiling::Transport::HTTP::Response.new(http_response)
-            end
-
-            def build_form(env)
-              flush = env.request.parcel.data
-              pprof_file = build_pprof(flush)
-
-              form = {
-                FORM_FIELD_INTAKE_VERSION => '3', # Aka 1.3 intake format
-                FORM_FIELD_RECORDING_START => flush.start.utc.iso8601,
-                FORM_FIELD_RECORDING_END => flush.finish.utc.iso8601,
-                FORM_FIELD_TAGS => [
-                  "#{FORM_FIELD_TAG_RUNTIME}:#{flush.language}",
-                  "#{FORM_FIELD_TAG_RUNTIME_ID}:#{flush.runtime_id}",
-                  "#{FORM_FIELD_TAG_RUNTIME_ENGINE}:#{flush.runtime_engine}",
-                  "#{FORM_FIELD_TAG_RUNTIME_PLATFORM}:#{flush.runtime_platform}",
-                  "#{FORM_FIELD_TAG_RUNTIME_VERSION}:#{flush.runtime_version}",
-                  "#{FORM_FIELD_TAG_PID}:#{Process.pid}",
-                  "#{FORM_FIELD_TAG_PROFILER_VERSION}:#{flush.profiler_version}",
-                  # NOTE: Redundant w/ 'runtime'; may want to remove this later.
-                  "#{FORM_FIELD_TAG_LANGUAGE}:#{flush.language}",
-                  "#{FORM_FIELD_TAG_HOST}:#{flush.host}",
-                  *flush
-                    .tags
-                    .reject { |tag_key| TAGS_TO_IGNORE_IN_TAGS_HASH.include?(tag_key) }
-                    .map { |tag_key, tag_value| "#{tag_key}:#{tag_value}" }
-                ],
-                FORM_FIELD_PPROF_DATA => pprof_file,
-                FORM_FIELD_FAMILY => flush.language,
-              }
-
-              # Optional fields
-              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_SERVICE}:#{flush.service}" unless flush.service.nil?
-              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_ENV}:#{flush.env}" unless flush.env.nil?
-              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_VERSION}:#{flush.version}" unless flush.version.nil?
-
-              # May not be available/enabled
-              form[FORM_FIELD_CODE_PROVENANCE_DATA] = build_code_provenance(flush) if flush.code_provenance
-
-              form
-            end
-
-            def build_pprof(flush)
-              pprof = encoder.encode(flush)
-
-              gzipped_pprof_data = Core::Utils::Compression.gzip(pprof.data)
-
-              Core::Vendor::Multipart::Post::UploadIO.new(
-                StringIO.new(gzipped_pprof_data),
-                HEADER_CONTENT_TYPE_OCTET_STREAM,
-                PPROF_DEFAULT_FILENAME
-              )
-            end
-
-            def build_code_provenance(flush)
-              gzipped_code_provenance = Core::Utils::Compression.gzip(flush.code_provenance)
-
-              Core::Vendor::Multipart::Post::UploadIO.new(
-                StringIO.new(gzipped_code_provenance),
-                HEADER_CONTENT_TYPE_OCTET_STREAM,
-                CODE_PROVENANCE_FILENAME,
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/transport/http/api/instance.rb

@@ -1,38 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/api/instance'
-require 'datadog/profiling/transport/http/api/spec'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        module API
-          # API instance for profiling
-          class Instance < Datadog::Transport::HTTP::API::Instance
-            def send_profiling_flush(env)
-              raise ProfilesNotSupportedError, spec unless spec.is_a?(Spec)
-
-              spec.send_profiling_flush(env) do |request_env|
-                call(request_env)
-              end
-            end
-
-            # Raised when profiles sent to API that does not support profiles
-            class ProfilesNotSupportedError < StandardError
-              attr_reader :spec
-
-              def initialize(spec)
-                @spec = spec
-              end
-
-              def message
-                'Profiles not supported for this API!'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/transport/http/api/spec.rb

@@ -1,42 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/api/spec'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        module API
-          # API specification for profiling
-          class Spec < Datadog::Transport::HTTP::API::Spec
-            attr_accessor \
-              :profiles
-
-            def send_profiling_flush(env, &block)
-              raise NoProfilesEndpointDefinedError, self if profiles.nil?
-
-              profiles.call(env, &block)
-            end
-
-            def encoder
-              profiles.encoder
-            end
-
-            # Raised when profiles sent but no profiles endpoint is defined
-            class NoProfilesEndpointDefinedError < StandardError
-              attr_reader :spec
-
-              def initialize(spec)
-                @spec = spec
-              end
-
-              def message
-                'No profiles endpoint is defined for API specification!'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/transport/http/api.rb

@@ -1,45 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/api/map'
-require 'datadog/profiling/encoding/profile'
-require 'datadog/profiling/transport/http/api/spec'
-require 'datadog/profiling/transport/http/api/instance'
-require 'datadog/profiling/transport/http/api/endpoint'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        # Extensions for HTTP API Spec
-        module API
-          # Default API versions
-          V1 = 'v1'.freeze
-
-          module_function
-
-          def agent_defaults
-            @agent_defaults ||= Datadog::Transport::HTTP::API::Map[
-              V1 => Spec.new do |s|
-                s.profiles = Endpoint.new(
-                  '/profiling/v1/input'.freeze,
-                  Profiling::Encoding::Profile::Protobuf
-                )
-              end
-            ]
-          end
-
-          def api_defaults
-            @api_defaults ||= Datadog::Transport::HTTP::API::Map[
-              V1 => Spec.new do |s|
-                s.profiles = Endpoint.new(
-                  '/v1/input'.freeze,
-                  Profiling::Encoding::Profile::Protobuf
-                )
-              end
-            ]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/transport/http/builder.rb

@@ -1,30 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/builder'
-
-require 'datadog/profiling/transport/http/api'
-require 'datadog/profiling/transport/http/client'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        # Builds new instances of Transport::HTTP::Client
-        class Builder < Datadog::Transport::HTTP::Builder
-          def api_instance_class
-            API::Instance
-          end
-
-          def to_transport
-            raise Datadog::Transport::HTTP::Builder::NoDefaultApiError if @default_api.nil?
-
-            # TODO: Profiling doesn't have multiple APIs yet.
-            #       When it does, we should build it out with these APIs.
-            #       Just use :default_api for now.
-            Client.new(to_api_instances[@default_api])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/transport/http/client.rb

@@ -1,35 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/client'
-require 'datadog/profiling/transport/client'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        # Routes, encodes, and sends tracer data to the trace agent via HTTP.
-        class Client < Datadog::Transport::HTTP::Client
-          include Transport::Client
-
-          def send_profiling_flush(flush)
-            # Build a request
-            request = Profiling::Transport::Request.new(flush)
-            send_payload(request).tap do |response|
-              if response.ok?
-                Datadog.logger.debug('Successfully reported profiling data')
-              else
-                Datadog.logger.debug { "Failed to report profiling data -- #{response.inspect}" }
-              end
-            end
-          end
-
-          def send_payload(request)
-            send_request(request) do |api, env|
-              api.send_profiling_flush(env)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/transport/http/response.rb

@@ -1,23 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/response'
-require 'datadog/profiling/transport/response'
-
-module Datadog
-  module Profiling
-    module Transport
-      # HTTP transport behavior for profiling
-      module HTTP
-        # Response from HTTP transport for profiling
-        class Response
-          include Datadog::Transport::HTTP::Response
-          include Profiling::Transport::Response
-
-          def initialize(http_response, options = {})
-            super(http_response)
-          end
-        end
-      end
-    end
-  end
-end