cybrid_api_bank_ruby 0.129.1137 → 0.129.1139

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/adapters/datadog.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "datadog/tracing/contrib/integration"
+require "datadog/tracing/contrib/configuration/settings"
+require "datadog/tracing/contrib/patcher"
+
+module Datadog::Tracing
+  module Contrib
+    module HTTPX
+      DATADOG_VERSION = defined?(::DDTrace) ? ::DDTrace::VERSION : ::Datadog::VERSION
+
+      METADATA_MODULE = Datadog::Tracing::Metadata
+
+      TYPE_OUTBOUND = Datadog::Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
+
+      TAG_BASE_SERVICE = if Gem::Version.new(DATADOG_VERSION::STRING) < Gem::Version.new("1.15.0")
+        "_dd.base_service"
+      elsif Gem::Version.new(DATADOG_VERSION::STRING) < Gem::Version.new("2.34.0")
+        Datadog::Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE
+      else
+        Datadog::Tracing::Metadata::Ext::TAG_BASE_SERVICE
+      end
+      TAG_PEER_HOSTNAME = Datadog::Tracing::Metadata::Ext::TAG_PEER_HOSTNAME
+      TAG_PEER_SERVICE = Datadog::Tracing::Metadata::Ext::TAG_PEER_SERVICE
+
+      TAG_KIND = Datadog::Tracing::Metadata::Ext::TAG_KIND
+      TAG_CLIENT = Datadog::Tracing::Metadata::Ext::SpanKind::TAG_CLIENT
+      TAG_COMPONENT = Datadog::Tracing::Metadata::Ext::TAG_COMPONENT
+      TAG_OPERATION = Datadog::Tracing::Metadata::Ext::TAG_OPERATION
+      TAG_URL = Datadog::Tracing::Metadata::Ext::HTTP::TAG_URL
+      TAG_METHOD = Datadog::Tracing::Metadata::Ext::HTTP::TAG_METHOD
+      TAG_TARGET_HOST = Datadog::Tracing::Metadata::Ext::NET::TAG_TARGET_HOST
+      TAG_TARGET_PORT = Datadog::Tracing::Metadata::Ext::NET::TAG_TARGET_PORT
+
+      TAG_STATUS_CODE = Datadog::Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE
+
+      # HTTPX Datadog Plugin
+      #
+      # Enables tracing for httpx requests.
+      #
+      # A span will be created for each request transaction; the span is created lazily only when
+      # buffering a request, and it is fed the start time stored inside the tracer object.
+      #
+      module Plugin
+        module RequestTracer
+          extend Contrib::HttpAnnotationHelper
+
+          module_function
+
+          SPAN_REQUEST = "httpx.request"
+
+          def enabled?(request)
+            configuration(request).enabled
+          end
+
+          def start(request)
+            request.datadog_span = initialize_span(request, request.init_time)
+          end
+
+          def reset(request)
+            request.datadog_span = nil
+          end
+
+          def finish(request, response)
+            request.datadog_span ||= initialize_span(request, request.init_time) if request.init_time
+
+            finish_span(response, request.datadog_span)
+          end
+
+          def finish_span(response, span)
+            if response.is_a?(::HTTPX::ErrorResponse)
+              span.set_error(response.error)
+            else
+              span.set_tag(TAG_STATUS_CODE, response.status.to_s)
+
+              span.set_error(::HTTPX::HTTPError.new(response)) if response.status.between?(400, 599)
+
+              span.set_tags(
+                Datadog.configuration.tracing.header_tags.response_tags(response.headers.to_h)
+              ) if Datadog.configuration.tracing.respond_to?(:header_tags)
+            end
+
+            span.finish
+          end
+
+          # return a span initialized with the +@request+ state.
+          def initialize_span(request, start_time)
+            verb = request.verb
+            uri = request.uri
+
+            config = configuration(request)
+
+            span = create_span(request, config, start_time)
+
+            span.resource = verb
+
+            # Tag original global service name if not used
+            span.set_tag(TAG_BASE_SERVICE, Datadog.configuration.service) if span.service != Datadog.configuration.service
+
+            span.set_tag(TAG_KIND, TAG_CLIENT)
+
+            span.set_tag(TAG_COMPONENT, "httpx")
+            span.set_tag(TAG_OPERATION, "request")
+
+            span.set_tag(TAG_URL, request.path)
+            span.set_tag(TAG_METHOD, verb)
+
+            span.set_tag(TAG_TARGET_HOST, uri.host)
+            span.set_tag(TAG_TARGET_PORT, uri.port)
+
+            span.set_tag(TAG_PEER_HOSTNAME, uri.host)
+
+            # Tag as an external peer service
+            if (peer_service = config[:peer_service])
+              span.set_tag(TAG_PEER_SERVICE, peer_service)
+            end
+
+            if config[:distributed_tracing]
+              propagate_trace_http(
+                Datadog::Tracing.active_trace,
+                request.headers
+              )
+            end
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(config[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+            end
+
+            span.set_tags(
+              Datadog.configuration.tracing.header_tags.request_tags(request.headers.to_h)
+            ) if Datadog.configuration.tracing.respond_to?(:header_tags)
+
+            span
+        rescue StandardError => e
+          Datadog.logger.error("error preparing span for http request: #{e}")
+          Datadog.logger.error(e.backtrace)
+          end
+
+          def configuration(request)
+            Datadog.configuration.tracing[:httpx, request.uri.host]
+          end
+
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("2.0.0")
+            def propagate_trace_http(trace, headers)
+              Datadog::Tracing::Contrib::HTTP.inject(trace, headers)
+            end
+
+            def create_span(request, configuration, start_time)
+              Datadog::Tracing.trace(
+                SPAN_REQUEST,
+                service: service_name(request.uri.host, configuration),
+                type: TYPE_OUTBOUND,
+                start_time: start_time
+              )
+            end
+          else
+            def propagate_trace_http(trace, headers)
+              Datadog::Tracing::Propagation::HTTP.inject!(trace.to_digest, headers)
+            end
+
+            def create_span(request, configuration, start_time)
+              Datadog::Tracing.trace(
+                SPAN_REQUEST,
+                service: service_name(request.uri.host, configuration),
+                span_type: TYPE_OUTBOUND,
+                start_time: start_time
+              )
+            end
+          end
+        end
+
+        class << self
+          def load_dependencies(klass)
+            klass.plugin(:tracing)
+          end
+
+          def extra_options(options)
+            options.merge(tracer: RequestTracer)
+          end
+        end
+
+        module RequestMethods
+          attr_accessor :datadog_span
+        end
+      end
+
+      # patches httpx debug logs to include datadog correlation ids
+      module LoggablePatch
+        def log_identifiers
+          "#{super} #{Datadog::Tracing.log_correlation}"
+        end
+      end
+
+      module Configuration
+        # Default settings for httpx
+        #
+        class Settings < Datadog::Tracing::Contrib::Configuration::Settings
+          DEFAULT_ERROR_HANDLER = lambda do |response|
+            Datadog::Ext::HTTP::ERROR_RANGE.cover?(response.status)
+          end
+
+          option :service_name, default: "httpx"
+          option :distributed_tracing, default: true
+          option :split_by_domain, default: false
+
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
+            option :enabled do |o|
+              o.type :bool
+              o.env "DD_TRACE_HTTPX_ENABLED"
+              o.default true
+            end
+
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env "DD_TRACE_HTTPX_ANALYTICS_ENABLED"
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env "DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE"
+              o.default 1.0
+            end
+
+            option :peer_service do |o|
+              o.type :string, nilable: true
+              o.env "DD_TRACE_HTTPX_PEER_SERVICE"
+            end
+          else
+            option :enabled do |o|
+              o.default { env_to_bool("DD_TRACE_HTTPX_ENABLED", true) }
+              o.lazy
+            end
+
+            option :analytics_enabled do |o|
+              o.default { env_to_bool(%w[DD_TRACE_HTTPX_ANALYTICS_ENABLED DD_HTTPX_ANALYTICS_ENABLED], false) }
+              o.lazy
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(%w[DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE DD_HTTPX_ANALYTICS_SAMPLE_RATE], 1.0) }
+              o.lazy
+            end
+
+            option :peer_service do |o|
+              o.default { env_to_string("DD_TRACE_HTTPX_PEER_SERVICE", nil) }
+              o.lazy
+            end
+          end
+
+          if defined?(Datadog::Tracing::Contrib::SpanAttributeSchema)
+            option :service_name do |o|
+              o.default do
+                Datadog::Tracing::Contrib::SpanAttributeSchema.fetch_service_name(
+                  "DD_TRACE_HTTPX_SERVICE_NAME",
+                  "httpx"
+                )
+              end
+              o.lazy unless Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
+            end
+          else
+            option :service_name do |o|
+              o.default do
+                ENV.fetch("DD_TRACE_HTTPX_SERVICE_NAME", "httpx")
+              end
+              o.lazy unless Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
+            end
+          end
+
+          option :distributed_tracing, default: true
+
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.15.0")
+            option :error_handler do |o|
+              o.type :proc
+              o.default_proc(&DEFAULT_ERROR_HANDLER)
+            end
+          elsif Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
+            option :error_handler do |o|
+              o.type :proc
+              o.experimental_default_proc(&DEFAULT_ERROR_HANDLER)
+            end
+          else
+            option :error_handler, default: DEFAULT_ERROR_HANDLER
+          end
+        end
+      end
+
+      # Patcher enables patching of 'httpx' with datadog components.
+      #
+      module Patcher
+        include Datadog::Tracing::Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        # loads a session instannce with the datadog plugin, and replaces the
+        # base HTTPX::Session with the patched session class.
+        def patch
+          datadog_session = ::HTTPX.plugin(Plugin)
+
+          ::HTTPX.send(:remove_const, :Session)
+          ::HTTPX.send(:const_set, :Session, datadog_session.class)
+
+          ::HTTPX::Loggable.singleton_class.prepend(LoggablePatch)
+        end
+      end
+
+      # Datadog Integration for HTTPX.
+      #
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new("0.10.2")
+
+        register_as :httpx
+
+        def self.version
+          Gem.loaded_specs["httpx"] && Gem.loaded_specs["httpx"].version
+        end
+
+        def self.loaded?
+          defined?(::HTTPX::Request)
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def new_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/adapters/faraday.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "httpx"
+require "faraday"
+
+module Faraday
+  class Adapter
+    class HTTPX < Faraday::Adapter
+      def initialize(app = nil, opts = {}, &block)
+        @connection = @bind = nil
+        super
+      end
+
+      module RequestMixin
+        def build_connection(env)
+          return @connection if @connection
+
+          @connection = ::HTTPX.plugin(:persistent).plugin(ReasonPlugin)
+          @connection = @connection.with(@connection_options) unless @connection_options.empty?
+          connection_opts = options_from_env(env)
+
+          if (bind = env.request.bind)
+            @bind = TCPSocket.new(bind[:host], bind[:port])
+            connection_opts[:io] = @bind
+          end
+          @connection = @connection.with(connection_opts)
+
+          if (proxy = env.request.proxy)
+            proxy_options = { uri: proxy.uri }
+            proxy_options[:username] = proxy.user if proxy.user
+            proxy_options[:password] = proxy.password if proxy.password
+
+            @connection = @connection.plugin(:proxy).with(proxy: proxy_options)
+          end
+          @connection = @connection.plugin(OnDataPlugin) if env.request.stream_response?
+
+          @connection = @config_block.call(@connection) || @connection if @config_block
+          @connection
+        end
+
+        def close
+          @connection.close if @connection
+          @bind.close if @bind
+        end
+
+        private
+
+        def connect(env, &blk)
+          connection(env, &blk)
+        rescue ::HTTPX::TLSError => e
+          raise Faraday::SSLError, e
+        rescue Errno::ECONNABORTED,
+               Errno::ECONNREFUSED,
+               Errno::ECONNRESET,
+               Errno::EHOSTUNREACH,
+               Errno::EINVAL,
+               Errno::ENETUNREACH,
+               Errno::EPIPE,
+               ::HTTPX::ConnectionError => e
+          raise Faraday::ConnectionFailed, e
+        rescue ::HTTPX::TimeoutError => e
+          raise Faraday::TimeoutError, e
+        end
+
+        def build_request(env)
+          meth = env[:method]
+
+          request_options = {
+            headers: env.request_headers,
+            body: env.body,
+            **options_from_env(env),
+          }
+          [meth.to_s.upcase, env.url, request_options]
+        end
+
+        def options_from_env(env)
+          timeout_options = {}
+          req_opts = env.request
+          if (sec = request_timeout(:read, req_opts))
+            timeout_options[:read_timeout] = sec
+          end
+
+          if (sec = request_timeout(:write, req_opts))
+            timeout_options[:write_timeout] = sec
+          end
+
+          if (sec = request_timeout(:open, req_opts))
+            timeout_options[:connect_timeout] = sec
+          end
+
+          {
+            ssl: ssl_options_from_env(env),
+            timeout: timeout_options,
+          }
+        end
+
+        if defined?(::OpenSSL)
+          def ssl_options_from_env(env)
+            ssl_options = {}
+
+            unless env.ssl.verify.nil?
+              ssl_options[:verify_mode] = env.ssl.verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+            end
+
+            ssl_options[:ca_file] = env.ssl.ca_file if env.ssl.ca_file
+            ssl_options[:ca_path] = env.ssl.ca_path if env.ssl.ca_path
+            ssl_options[:cert_store] = env.ssl.cert_store if env.ssl.cert_store
+            ssl_options[:cert] = env.ssl.client_cert if env.ssl.client_cert
+            ssl_options[:key] = env.ssl.client_key if env.ssl.client_key
+            ssl_options[:ssl_version] = env.ssl.version if env.ssl.version
+            ssl_options[:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
+            ssl_options[:min_version] = env.ssl.min_version if env.ssl.min_version
+            ssl_options[:max_version] = env.ssl.max_version if env.ssl.max_version
+            ssl_options
+          end
+        else
+          # simplecov:disable
+          def ssl_options_from_env(*)
+            {}
+          end
+          # simplecov:enable
+        end
+      end
+
+      include RequestMixin
+
+      module OnDataPlugin
+        module RequestMethods
+          attr_writer :response_on_data
+
+          def response=(response)
+            super
+
+            return unless @response
+
+            return if @response.is_a?(::HTTPX::ErrorResponse)
+
+            @response.body.on_data = @response_on_data
+          end
+        end
+
+        module ResponseBodyMethods
+          attr_writer :on_data
+
+          def write(chunk)
+            return super unless @on_data
+
+            @on_data.call(chunk, chunk.bytesize)
+          end
+        end
+      end
+
+      module ReasonPlugin
+        def self.load_dependencies(*)
+          require "net/http/status"
+        end
+
+        module ResponseMethods
+          def reason
+            Net::HTTP::STATUS_CODES.fetch(@status, "Non-Standard status code")
+          end
+        end
+      end
+
+      class ParallelManager
+        class ResponseHandler < SimpleDelegator
+          attr_reader :env
+
+          def initialize(env)
+            @env = env
+            super
+          end
+
+          def on_response(&blk)
+            if blk
+              @on_response = ->(response) do
+                blk.call(response)
+              end
+              self
+            else
+              @on_response
+            end
+          end
+        end
+
+        include RequestMixin
+
+        def initialize(options)
+          @handlers = []
+          @connection_options = options
+        end
+
+        def enqueue(request)
+          handler = ResponseHandler.new(request)
+          @handlers << handler
+          handler
+        end
+
+        def run
+          return unless @handlers.last
+
+          env = @handlers.last.env
+
+          connect(env) do |session|
+            requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
+
+            if env.request.stream_response?
+              requests.each do |request|
+                request.response_on_data = env.request.on_data
+              end
+            end
+
+            responses = session.request(*requests)
+            Array(responses).each_with_index do |response, index|
+              handler = @handlers[index]
+              handler.on_response.call(response)
+            end
+          end
+        end
+
+        private
+
+        # from Faraday::Adapter#connection
+        def connection(env)
+          conn = build_connection(env)
+          return conn unless block_given?
+
+          yield conn
+        end
+
+        # from Faraday::Adapter#request_timeout
+        def request_timeout(type, options)
+          key = Faraday::Adapter::TIMEOUT_KEYS[type]
+          options[key] || options[:timeout]
+        end
+      end
+
+      self.supports_parallel = true
+
+      class << self
+        def setup_parallel_manager(options = {})
+          ParallelManager.new(options)
+        end
+      end
+
+      def call(env)
+        super
+        if parallel?(env)
+          handler = env[:parallel_manager].enqueue(env)
+          handler.on_response do |response|
+            if response.is_a?(::HTTPX::Response)
+              save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
+                response_headers.merge!(response.headers)
+              end
+            else
+              env[:error] = response.error
+              save_response(env, 0, "", {}, nil)
+            end
+          end
+          return handler
+        end
+
+        response = connect_and_request(env)
+        save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
+          response_headers.merge!(response.headers)
+        end
+        @app.call(env)
+      end
+
+      private
+
+      def connect_and_request(env)
+        connect(env) do |session|
+          request = session.build_request(*build_request(env))
+
+          request.response_on_data = env.request.on_data if env.request.stream_response?
+
+          response = session.request(request)
+          # do not call #raise_for_status for HTTP 4xx or 5xx, as faraday has a middleware for that.
+          response.raise_for_status unless response.is_a?(::HTTPX::Response)
+          response
+        end
+      end
+
+      def parallel?(env)
+        env[:parallel_manager]
+      end
+    end
+
+    register_middleware httpx: HTTPX
+  end
+end