datadog 2.10.0 → 2.11.0

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Rack
-        module Reactive
-          # Dispatch data from a Rack request to the WAF context
-          module Request
-            ADDRESSES = [
-              'request.headers',
-              'request.uri.raw',
-              'request.query',
-              'request.cookies',
-              'request.client_ip',
-              'server.request.method'
-            ].freeze
-            private_constant :ADDRESSES
-
-            def self.publish(engine, gateway_request)
-              catch(:block) do
-                engine.publish('request.query', gateway_request.query)
-                engine.publish('request.headers', gateway_request.headers)
-                engine.publish('request.uri.raw', gateway_request.fullpath)
-                engine.publish('request.cookies', gateway_request.cookies)
-                engine.publish('request.client_ip', gateway_request.client_ip)
-                engine.publish('server.request.method', gateway_request.method)
-
-                nil
-              end
-            end
-
-            def self.subscribe(engine, context)
-              engine.subscribe(*ADDRESSES) do |*values|
-                Datadog.logger.debug { "reacted to #{ADDRESSES.inspect}: #{values.inspect}" }
-
-                headers = values[0]
-                headers_no_cookies = headers.dup.tap { |h| h.delete('cookie') }
-                uri_raw = values[1]
-                query = values[2]
-                cookies = values[3]
-                client_ip = values[4]
-                request_method = values[5]
-
-                persistent_data = {
-                  'server.request.cookies' => cookies,
-                  'server.request.query' => query,
-                  'server.request.uri.raw' => uri_raw,
-                  'server.request.headers' => headers,
-                  'server.request.headers.no_cookies' => headers_no_cookies,
-                  'http.client_ip' => client_ip,
-                  'server.request.method' => request_method,
-                }
-
-                waf_timeout = Datadog.configuration.appsec.waf_timeout
-                result = context.run_waf(persistent_data, {}, waf_timeout)
-
-                next unless result.match?
-
-                yield result
-                throw(:block, true) unless result.actions.empty?
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/contrib/rack/reactive/request_body.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Rack
-        module Reactive
-          # Dispatch data from a Rack request to the WAF context
-          module RequestBody
-            ADDRESSES = [
-              'request.body',
-            ].freeze
-            private_constant :ADDRESSES
-
-            def self.publish(engine, gateway_request)
-              catch(:block) do
-                # params have been parsed from the request body
-                engine.publish('request.body', gateway_request.form_hash)
-
-                nil
-              end
-            end
-
-            def self.subscribe(engine, context)
-              engine.subscribe(*ADDRESSES) do |*values|
-                Datadog.logger.debug { "reacted to #{ADDRESSES.inspect}: #{values.inspect}" }
-                body = values[0]
-
-                persistent_data = {
-                  'server.request.body' => body,
-                }
-
-                waf_timeout = Datadog.configuration.appsec.waf_timeout
-                result = context.run_waf(persistent_data, {}, waf_timeout)
-
-                next unless result.match?
-
-                yield result
-                throw(:block, true) unless result.actions.empty?
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Rack
-        module Reactive
-          # Dispatch data from a Rack response to the WAF context
-          module Response
-            ADDRESSES = [
-              'response.status',
-              'response.headers',
-            ].freeze
-            private_constant :ADDRESSES
-
-            def self.publish(engine, gateway_response)
-              catch(:block) do
-                engine.publish('response.status', gateway_response.status)
-                engine.publish('response.headers', gateway_response.headers)
-
-                nil
-              end
-            end
-
-            def self.subscribe(engine, context)
-              engine.subscribe(*ADDRESSES) do |*values|
-                Datadog.logger.debug { "reacted to #{ADDRESSES.inspect}: #{values.inspect}" }
-
-                response_status = values[0]
-                response_headers = values[1]
-                response_headers_no_cookies = response_headers.dup.tap { |h| h.delete('set-cookie') }
-
-                persistent_data = {
-                  'server.response.status' => response_status.to_s,
-                  'server.response.headers' => response_headers,
-                  'server.response.headers.no_cookies' => response_headers_no_cookies,
-                }
-
-                waf_timeout = Datadog.configuration.appsec.waf_timeout
-                result = context.run_waf(persistent_data, {}, waf_timeout)
-
-                next unless result.match?
-
-                yield result
-                throw(:block, true) unless result.actions.empty?
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/contrib/rails/reactive/action.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../request'
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Rails
-        module Reactive
-          # Dispatch data from a Rails request to the WAF context
-          module Action
-            ADDRESSES = [
-              'rails.request.body',
-              'rails.request.route_params',
-            ].freeze
-            private_constant :ADDRESSES
-
-            def self.publish(engine, gateway_request)
-              catch(:block) do
-                # params have been parsed from the request body
-                engine.publish('rails.request.body', gateway_request.parsed_body)
-                engine.publish('rails.request.route_params', gateway_request.route_params)
-
-                nil
-              end
-            end
-
-            def self.subscribe(engine, context)
-              engine.subscribe(*ADDRESSES) do |*values|
-                Datadog.logger.debug { "reacted to #{ADDRESSES.inspect}: #{values.inspect}" }
-                body = values[0]
-                path_params = values[1]
-
-                persistent_data = {
-                  'server.request.body' => body,
-                  'server.request.path_params' => path_params,
-                }
-
-                waf_timeout = Datadog.configuration.appsec.waf_timeout
-                result = context.run_waf(persistent_data, {}, waf_timeout)
-
-                next unless result.match?
-
-                yield result
-                throw(:block, true) unless result.actions.empty?
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/contrib/sinatra/reactive/routed.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Contrib
-      module Sinatra
-        module Reactive
-          # Dispatch data from a Sinatra request to the WAF context
-          module Routed
-            ADDRESSES = [
-              'sinatra.request.route_params',
-            ].freeze
-            private_constant :ADDRESSES
-
-            def self.publish(engine, data)
-              _request, route_params = data
-
-              catch(:block) do
-                engine.publish('sinatra.request.route_params', route_params.params)
-
-                nil
-              end
-            end
-
-            def self.subscribe(engine, context)
-              engine.subscribe(*ADDRESSES) do |*values|
-                Datadog.logger.debug { "reacted to #{ADDRESSES.inspect}: #{values.inspect}" }
-                path_params = values[0]
-
-                persistent_data = {
-                  'server.request.path_params' => path_params,
-                }
-
-                waf_timeout = Datadog.configuration.appsec.waf_timeout
-                result = context.run_waf(persistent_data, {}, waf_timeout)
-
-                next unless result.match?
-
-                yield result
-                throw(:block, true) unless result.actions.empty?
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/monitor/reactive/set_user.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Monitor
-      module Reactive
-        # Dispatch data from Datadog::Kit::Identity.set_user to the WAF context
-        module SetUser
-          ADDRESSES = [
-            'usr.id',
-          ].freeze
-          private_constant :ADDRESSES
-
-          def self.publish(engine, user)
-            catch(:block) do
-              engine.publish('usr.id', user.id)
-
-              nil
-            end
-          end
-
-          def self.subscribe(engine, context)
-            engine.subscribe(*ADDRESSES) do |*values|
-              Datadog.logger.debug { "reacted to #{ADDRESSES.inspect}: #{values.inspect}" }
-
-              user_id = values[0]
-
-              persistent_data = {
-                'usr.id' => user_id,
-              }
-
-              waf_timeout = Datadog.configuration.appsec.waf_timeout
-              result = context.run_waf(persistent_data, {}, waf_timeout)
-
-              next unless result.match?
-
-              yield result
-              throw(:block, true) unless result.actions.empty?
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/reactive/address_hash.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Reactive
-      # AddressHash for Reactive Engine
-      class AddressHash < Hash
-        def self.new(*arguments, &block)
-          super { |h, k| h[k] = [] }
-        end
-
-        def addresses
-          keys.flatten
-        end
-
-        def with(address)
-          keys.select { |k| k.include?(address) }
-        end
-      end
-    end
-  end
-end

data/lib/datadog/appsec/reactive/engine.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'address_hash'
-require_relative 'subscriber'
-
-module Datadog
-  module AppSec
-    module Reactive
-      # Reactive Engine
-      class Engine
-        def initialize
-          @data = {}
-          @subscribers = AddressHash.new
-        end
-
-        def subscribe(*addresses, &block)
-          @subscribers[addresses.freeze] << Subscriber.new(&block)
-        end
-
-        def publish(address, value)
-          # check if someone has address subscribed
-          if @subscribers.addresses.include?(address)
-
-            # someone will be interested, set value
-            @data[address] = value
-
-            # find candidates i.e address groups that contain the just posted address
-            @subscribers.with(address).each do |addresses|
-              # find targets to the address group containing the posted address
-              subscribers = @subscribers[addresses]
-
-              # is all data for the targets available?
-              if (addresses - @data.keys).empty?
-                hash = addresses.each_with_object({}) { |a, h| h[a] = @data[a] }
-                subscribers.each { |s| s.call(*hash.values) }
-              end
-            end
-          end
-        end
-
-        private
-
-        attr_reader :subscribers, :data
-      end
-    end
-  end
-end

data/lib/datadog/appsec/reactive/subscriber.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Reactive
-      # Reactive Engine subscriber
-      class Subscriber
-        def initialize(&block)
-          @block = block
-          freeze
-        end
-
-        def call(*args)
-          @block.call(*args)
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/remote/transport/http/api/instance.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Remote
-      module Transport
-        module HTTP
-          module API
-            # An API configured with adapter and routes
-            class Instance
-              attr_reader \
-                :adapter,
-                :headers,
-                :spec
-
-              def initialize(spec, adapter, options = {})
-                @spec = spec
-                @adapter = adapter
-                @headers = options.fetch(:headers, {})
-              end
-
-              def encoder
-                spec.encoder
-              end
-
-              def call(env)
-                # Add headers to request env, unless empty.
-                env.headers.merge!(headers) unless headers.empty?
-
-                # Send request env to the adapter.
-                adapter.call(env)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/remote/transport/http/api/spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Remote
-      module Transport
-        module HTTP
-          module API
-            # Specification for an HTTP API
-            # Defines behaviors without specific configuration details.
-            class Spec
-              def initialize
-                yield(self) if block_given?
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/remote/transport/http/builder.rb

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../configuration/agent_settings_resolver'
-require_relative '../../../transport/http/adapters/registry'
-require_relative '../../../transport/http/api/map'
-
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/trace includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../../datadog/core/transport/http/api/instance'
-require_relative 'api/instance'
-
-# TODO: Decouple transport/http/client
-#
-# The standard one does `include Transport::HTTP::Statistics` and performs
-# stats updates, which may or may not be desirable in general.
-#
-# Below should be:
-# require_relative '../../../../datadog/core/transport/http/client'
-require_relative 'client'
-
-# TODO: Decouple transport/http/builder
-#
-# This class is duplicated even though it is tantalisingly close to the
-# one in datadog/core/transport mostly because it refers to a different
-# `API::Instance` in `#api_instance_class` but also because it operates on a
-# different `HTTP::Client`, as well as de-hardcoding the transport class
-# `Transport::Traces::Transport` in `#to_transport`
-#
-# Additionally, its design makes it so there can be only one (API, Client,
-# Transport) triplet, requiring a new transport instance for any varying
-# element of the triplet.
-
-module Datadog
-  module Core
-    module Remote
-      module Transport
-        module HTTP
-          # Builds new instances of Transport::HTTP::Client
-          class Builder
-            REGISTRY = Datadog::Core::Transport::HTTP::Adapters::Registry.new
-
-            attr_reader \
-              :apis,
-              :api_options,
-              :default_adapter,
-              :default_api,
-              :default_headers
-
-            def initialize
-              # Global settings
-              @default_adapter = nil
-              @default_headers = {}
-
-              # Client settings
-              @apis = Datadog::Core::Transport::HTTP::API::Map.new
-              @default_api = nil
-
-              # API settings
-              @api_options = {}
-
-              yield(self) if block_given?
-            end
-
-            def adapter(config, *args, **kwargs)
-              @default_adapter = case config
-                                 when Core::Configuration::AgentSettingsResolver::AgentSettings
-                                   registry_klass = REGISTRY.get(config.adapter)
-                                   raise UnknownAdapterError, config.adapter if registry_klass.nil?
-
-                                   registry_klass.build(config)
-                                 when Symbol
-                                   registry_klass = REGISTRY.get(config)
-                                   raise UnknownAdapterError, config if registry_klass.nil?
-
-                                   registry_klass.new(*args, **kwargs)
-                                 else
-                                   config
-                                 end
-            end
-
-            def headers(values = {})
-              @default_headers.merge!(values)
-            end
-
-            # Adds a new API to the client
-            # Valid options:
-            #  - :adapter
-            #  - :default
-            #  - :fallback
-            #  - :headers
-            def api(key, spec, options = {})
-              options = options.dup
-
-              # Copy spec into API map
-              @apis[key] = spec
-
-              # Apply as default API, if specified to do so.
-              @default_api = key if options.delete(:default) || @default_api.nil?
-
-              # Save all other settings for initialization
-              (@api_options[key] ||= {}).merge!(options)
-            end
-
-            def default_api=(key)
-              raise UnknownApiError, key unless @apis.key?(key)
-
-              @default_api = key
-            end
-
-            def to_transport(klass)
-              raise NoDefaultApiError if @default_api.nil?
-
-              klass.new(to_api_instances, @default_api)
-            end
-
-            def to_api_instances
-              raise NoApisError if @apis.empty?
-
-              @apis.inject(Datadog::Core::Transport::HTTP::API::Map.new) do |instances, (key, spec)|
-                instances.tap do
-                  api_options = @api_options[key].dup
-
-                  # Resolve the adapter to use for this API
-                  adapter = api_options.delete(:adapter) || @default_adapter
-                  raise NoAdapterForApiError, key if adapter.nil?
-
-                  # Resolve fallback and merge headers
-                  fallback = api_options.delete(:fallback)
-                  api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
-
-                  # Add API::Instance with all settings
-                  instances[key] = api_instance_class.new(
-                    spec,
-                    adapter,
-                    api_options
-                  )
-
-                  # Configure fallback, if provided.
-                  instances.with_fallbacks(key => fallback) unless fallback.nil?
-                end
-              end
-            end
-
-            def api_instance_class
-              API::Instance
-            end
-
-            # Raised when the API key does not match known APIs.
-            class UnknownApiError < StandardError
-              attr_reader :key
-
-              def initialize(key)
-                super()
-
-                @key = key
-              end
-
-              def message
-                "Unknown transport API '#{key}'!"
-              end
-            end
-
-            # Raised when the identifier cannot be matched to an adapter.
-            class UnknownAdapterError < StandardError
-              attr_reader :type
-
-              def initialize(type)
-                super()
-
-                @type = type
-              end
-
-              def message
-                "Unknown transport adapter '#{type}'!"
-              end
-            end
-
-            # Raised when an adapter cannot be resolved for an API instance.
-            class NoAdapterForApiError < StandardError
-              attr_reader :key
-
-              def initialize(key)
-                super()
-
-                @key = key
-              end
-
-              def message
-                "No adapter resolved for transport API '#{key}'!"
-              end
-            end
-
-            # Raised when built without defining APIs.
-            class NoApisError < StandardError
-              def message
-                'No APIs configured for transport!'
-              end
-            end
-
-            # Raised when client built without defining a default API.
-            class NoDefaultApiError < StandardError
-              def message
-                'No default API configured for transport!'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end