alogram_payrisk 0.3.0 → 0.3.1

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/lib/http/2/stream.rb

@@ -114,8 +114,10 @@ module HTTP2
     def receive(frame)
       transition(frame, false)
 
-      case frame[:type]
+      frame_type = frame[:type] #: Symbol
+      case frame_type
       when :data
+        # @type var frame: data_frame
         # 6.1. DATA
         # If a DATA frame is received whose stream is not in "open" or
         # "half closed (local)" state, the recipient MUST respond with a
@@ -129,6 +131,7 @@ module HTTP2
         emit(:data, frame[:payload]) unless frame[:ignore]
         calculate_window_update(@local_window_max_size)
       when :headers
+        # @type var frame: headers_frame
         stream_error(:stream_closed) if (@state == :closed && @closed != :local_rst) ||
                                         @state == :remote_closed
         @_method ||= frame[:method]
@@ -151,17 +154,18 @@ module HTTP2
         stream_error(:stream_closed) if (@state == :closed && @closed != :local_rst) || @state == :remote_closed
         stream_error(:protocol_error) if @received_data
       when :priority
+        # @type var frame: priority_frame
         process_priority(frame)
       when :window_update
+        # @type var frame: window_update_frame
         process_window_update(frame: frame)
       when :altsvc
+        # @type var frame: origin_frame
         # 4.  The ALTSVC HTTP/2 Frame
         # An ALTSVC frame on a
         # stream other than stream 0 containing non-empty "Origin" information
         # is invalid and MUST be ignored.
-        emit(frame[:type], frame) if !frame[:origin] || frame[:origin].empty?
-      when :blocked
-        emit(frame[:type], frame)
+        emit(frame_type, frame) if !frame[:origin] || frame[:origin].empty?
       end
 
       complete_transition(frame)
@@ -199,11 +203,14 @@ module HTTP2
     def send(frame)
       case frame[:type]
       when :data
+        # @type var frame: data_frame
         # stream state management is maintained in send_data
         return send_data(frame)
       when :window_update
+        # @type var frame: window_update_frame
         @local_window += frame[:increment]
       when :priority
+        # @type var frame: priority_frame
         process_priority(frame)
       end
 
@@ -219,9 +226,8 @@ module HTTP2
     # @param end_headers [Boolean] indicates that no more headers will be sent
     # @param end_stream [Boolean] indicates that no payload will be sent
     def headers(headers, end_headers: true, end_stream: false)
-      flags = []
-      flags << :end_headers if end_headers
-      flags << :end_stream  if end_stream || @_method == "HEAD"
+      flags = end_headers ? END_HEADERS : 0
+      flags |= END_STREAM  if end_stream || @_method == "HEAD"
 
       send(type: :headers, flags: flags, payload: headers)
     end
@@ -229,7 +235,7 @@ module HTTP2
     def promise(headers, end_headers: true, &block)
       raise ArgumentError, "must provide callback" unless block
 
-      flags = end_headers ? [:end_headers] : []
+      flags = end_headers ? END_HEADERS : 0
       emit(:promise, self, headers, flags, &block)
     end
 
@@ -254,12 +260,12 @@ module HTTP2
 
       if payload.bytesize > max_size
         payload = chunk_data(payload, max_size) do |chunk|
-          send(type: :data, flags: [], payload: chunk)
+          send(type: :data, flags: 0, payload: chunk)
         end
       end
 
-      flags = []
-      flags << :end_stream if end_stream
+      flags = 0
+      flags |= END_STREAM if end_stream
       send(type: :data, flags: flags, payload: payload)
     end
 
@@ -663,7 +669,8 @@ module HTTP2
     def end_stream?(frame)
       case frame[:type]
       when :data, :headers, :continuation
-        frame[:flags] && frame[:flags].include?(:end_stream)
+        # @type var frame: data_frame | headers_frame | continuation_frame
+        frame[:flags] && frame[:flags].anybits?(END_STREAM)
       else false
       end
     end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/lib/http/2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP2
-  VERSION = "1.1.3"
+  VERSION = "1.2.0"
 end

data/vendor/bundle/ruby/3.3.0/gems/http-2-1.2.0/sig/2.rbs

@@ -0,0 +1,161 @@
+module HTTP2
+  VERSION: String
+
+  DEFAULT_FLOW_WINDOW: Integer
+
+  DEFAULT_HEADER_SIZE: Integer
+
+  DEFAULT_MAX_CONCURRENT_STREAMS: Integer
+
+  EMPTY: []
+
+  type connection_opts = Hash[Symbol, untyped]
+
+  type settings_hash = {
+    settings_header_table_size: Integer,
+    settings_enable_push: Integer,
+    settings_max_concurrent_streams:  Integer,
+    settings_initial_window_size: Integer,
+    settings_max_frame_size: Integer,
+    settings_max_header_list_size: Integer
+  }
+
+  type settings_ary = Array[settings_enum]
+
+  type settings_enum = Enumerable[[Symbol, Integer]]
+
+  SPEC_DEFAULT_CONNECTION_SETTINGS: settings_hash
+
+  DEFAULT_CONNECTION_SETTINGS: settings_hash
+
+  DEFAULT_WEIGHT: Integer
+
+  CONNECTION_PREFACE_MAGIC: String
+
+  REQUEST_MANDATORY_HEADERS: Array[String]
+
+  RESPONSE_MANDATORY_HEADERS: Array[String]
+
+  # Frame flags
+  END_STREAM: Integer
+  ACK: Integer
+  RESERVED: Integer
+  END_HEADERS: Integer
+  PADDED: Integer
+  PRIORITY: Integer
+
+  type header_pair = [string, string]
+
+  # # FRAMES
+  type frame_control_flags = Integer
+
+  type common_frame = { stream: Integer, flags: frame_control_flags, ?length: Integer, ?ignore: bool }
+
+  type connection_frame = settings_frame | ping_frame | goaway_frame | window_update_frame | altsvc_frame | origin_frame
+
+  # # HEADERS
+  type headers_frame_props = {
+    type: :headers, payload: Enumerable[header_pair] | String,
+    ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, ?padding: Integer
+  }
+  type headers_frame = common_frame & headers_frame_props
+
+  type continuation_frame_props = headers_frame_props | { type: :continuation }
+
+  type continuation_frame = common_frame & continuation_frame_props
+
+  # # DATA
+  type data_frame_props = { type: :data, ?length: Integer, payload: String, ?padding: Integer }
+
+  type data_frame = common_frame & data_frame_props
+
+  # # PUSH_PROMISE
+  type push_promise_frame_props = { promise_stream: Integer, ?length: Integer, ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, payload: Enumerable[header_pair] | String, ?padding: Integer }
+
+  type push_promise_frame = common_frame & push_promise_frame_props
+
+  # # SETTINGS
+  type settings_frame_props = { type: :settings, payload: (Enumerable[[Symbol | Integer, Integer]] | String) }
+
+  type settings_frame = common_frame & settings_frame_props
+
+  # # WINDOW_UPDATE
+  type window_update_frame_props = { type: :window_update, increment: Integer }
+
+  type window_update_frame = common_frame & window_update_frame_props
+
+  # # PRIORITY
+  type priority_frame_inner_props = { dependency: Integer, exclusive: bool, weight: Integer }
+
+  type priority_frame_props = { type: :priority } & priority_frame_inner_props
+
+  type priority_frame = common_frame & priority_frame_props
+
+  # # ALTSVC
+  type altsvc_frame_props = { type: :altsvc, max_age: Integer, port: Integer, proto: String, host: String }
+
+  type altsvc_frame = common_frame & altsvc_frame_props
+
+  # # ORIGIN
+  type origin_frame_props = { type: :origin, payload: Array[String] }
+
+  type origin_frame = common_frame & origin_frame_props
+
+  # # PING
+  type ping_frame_props = { type: :ping, payload: String }
+
+  type ping_frame = common_frame & ping_frame_props
+
+  # # GOAWAY
+  type goaway_frame_props = { type: :goaway, last_stream: Integer, error: (Symbol | Integer)? }
+
+  type goaway_frame = common_frame & goaway_frame_props
+
+  # # RST_STREAM
+  type rst_stream_frame_props = { type: :rst_stream, error: (Symbol | Integer)? }
+
+  type rst_stream_frame = common_frame & rst_stream_frame_props
+
+  # type frame = headers_frame | continuation_frame | push_promise_frame | data_frame |
+  #              settings_frame | window_update_frame | priority_frame | altsvc_frame |
+  #              origin_frame | ping_frame | goaway_frame | rst_stream_frame
+
+  # type connection_frame_props = rst_stream_frame_props | ping_frame_props | goaway_frame_props
+  #                             | window_update_frame_props | settings_frame_props
+
+  # type stream_frame_props = headers_frame_props | continuation_frame_props | push_promise_frame_props
+  #                         | data_frame_props  | rst_stream_frame_props | priority_frame_props
+  #                         | window_update_frame_props | origin_frame_props | altsvc_frame_props
+
+  type frame_key = :type | :flags | :stream | :padding | :ignore |
+                   # headers
+                   :method | :trailer | :content_length | :status |
+                   # data, settings, ping
+                   :payload | :length |
+                   # promise
+                   :promise_stream |
+                   # window_update
+                   :increment |
+                   # priority
+                   :dependency | :exclusive | :weight |
+                   # altsvc
+                   :max_age | :port | :proto | :host |
+                   # origin
+                   :origin |
+                   # goaway
+                   :last_stream | :error
+
+  type frame_value = Integer |
+                     Symbol | # type (:data, :headers)
+                     Array[Symbol] |
+                     String |
+                     bool |
+                     Array[String] |
+                     Array[[Symbol | Integer, Integer]] |
+                     Enumerable[header_pair] |
+                     nil
+
+  type frame = Hash[frame_key, frame_value]
+  type connection_frame_props = Hash[frame_key, frame_value]
+  type stream_frame_props = Hash[frame_key, frame_value]
+end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/connection.rbs

@@ -33,6 +33,7 @@ module HTTP2
 
     @streams: Hash[Integer, Stream]
     @streams_recently_closed: Hash[Integer, Numeric]
+    @oldest_stream_recently_closed: Numeric
 
     @framer: Framer
 
@@ -50,6 +51,7 @@ module HTTP2
 
     @recv_buffer: String
     @continuation: Array[frame]
+    @continuation_size: Integer
 
     @h2c_upgrade: Symbol?
     @closed_since: Float?
@@ -68,39 +70,39 @@ module HTTP2
 
     def settings: (settings_enum payload) -> void
 
-    def receive: (string data) -> void
+    def receive: (String data) -> void
     alias << receive
 
     def initialize: (?connection_opts) -> void
 
     private
 
-    def send: (frame frame) -> void
+    def send: (connection_frame_props | stream_frame_props frame) -> void
 
     def encode: (frame frame) -> void
 
     def connection_frame?: (frame) -> bool
 
-    def connection_management: (frame) -> void
+    def connection_management: (connection_frame frame) -> void
 
     def ping_management: (frame) -> void
 
     def validate_settings: (role_type, settings_enum) -> void
 
-    def connection_settings: (frame) -> void
+    def connection_settings: (settings_frame) -> void
 
-    def decode_headers: (frame) -> void
+    def decode_headers: (headers_frame | push_promise_frame) -> void
 
-    def encode_headers: (frame headers_frame) -> void
+    def encode_headers: (headers_frame | push_promise_frame) -> void
 
     def activate_stream: (id: Integer, **untyped) -> Stream
 
     def verify_stream_order: (Integer id) -> void
 
-    def verify_pseudo_headers: (frame) -> void
+    def verify_pseudo_headers: (headers_frame | push_promise_frame) -> void
 
-    def _verify_pseudo_headers: (frame, Array[String]) -> void
+    def _verify_pseudo_headers: (headers_frame | push_promise_frame, Array[String]) -> void
 
     def connection_error: (?Symbol error, ?msg: String?, ?e: StandardError?) -> void
   end
-end
+end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/flow_buffer.rbs

@@ -14,9 +14,9 @@ module HTTP2
 
     def calculate_window_update: (Integer) -> void
 
-    def send_data: (?data_frame? frame, ?bool encode) -> void
+    def send_data: (?data_frame_props? frame, ?bool encode) -> void
 
-    def send_frame: (data_frame frame, bool encode) -> void
+    def send_frame: (data_frame_props frame, bool encode) -> void
 
     def process_window_update: (frame: window_update_frame, ?encode: bool) -> void
   end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/frame_buffer.rbs

@@ -1,15 +1,17 @@
 module HTTP2
   class FrameBuffer
+    include BufferUtils
+
     attr_reader bytesize: Integer
 
     @buffer: Array[data_frame]
 
     def clear: () -> void
 
-    def <<: (data_frame frame) -> void
+    def <<: (data_frame_props frame) -> void
 
     def empty?: () -> bool
 
-    def retrieve: (Integer) -> data_frame?
+    def retrieve: (Integer) -> data_frame_props?
   end
 end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/framer.rbs

@@ -20,7 +20,9 @@ module HTTP2
 
     DEFINED_SETTINGS: Hash[Symbol, Integer]
 
-    DEFINED_ERRORS: Hash[Symbol, Integer]
+    DEFINED_SETTINGS_BY_ID: Hash[Integer, Symbol]
+
+    DEFINED_ERRORS: Array[Symbol]
 
     RBIT: Integer
     RBYTE: Integer
@@ -29,6 +31,8 @@ module HTTP2
     UINT16: String
     UINT8: String
     HEADERPACK: String
+    PRIORITYPACK: String
+    ALTSVCPACK: String
     FRAME_LENGTH_HISHIFT: Integer
     FRAME_LENGTH_LOMASK: Integer
 
@@ -41,19 +45,19 @@ module HTTP2
 
     def common_header: (frame, buffer: String) -> String
 
-    def read_common_header: (String buf) -> frame
+    def read_common_header: (String buf) -> (common_frame | { length: Integer })
 
     def read_common_frame: (String) -> frame
 
     def generate: (frame) -> String
 
-    def parse: (String) -> frame?
+    def parse: (String) -> (frame | { length: Integer })?
 
     private
 
     def initialize: (?Integer local_max_frame_size, ?Integer remote_max_frame_size) -> untyped
 
-    def pack_error: (Integer | Symbol error, buffer: String) -> String
+    def pack_error: (Symbol | Integer error, buffer: String) -> String
 
     def unpack_error: (Integer) -> (Symbol | Integer)
   end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/header/compressor.rbs

@@ -2,6 +2,7 @@ module HTTP2
   module Header
     class Compressor
       include PackingExtensions
+      include BufferUtils
 
       @cc: EncodingContext
 

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/header/encoding_context.rbs

@@ -22,6 +22,10 @@ module HTTP2
 
       attr_reader current_table_size: Integer
 
+      @table_by_field: Hash[string, Array[[string, Integer]]]
+
+      @unshifts: Integer
+
       @limit: Integer
 
       @_table_updated: bool

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/header/huffman.rbs

@@ -9,6 +9,8 @@ module HTTP2
 
       EOS: Integer
 
+      EOS_PADDING: Array[String]
+
       CODES: Array[[Integer, Integer]]
 
       ENCODE_TABLE: Array[String]

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/server.rbs

@@ -7,6 +7,6 @@ module HTTP2
 
     private
 
-    def promise: (Stream parent, Enumerable[header_pair] headers, Array[Symbol] flags) { (Stream) -> void } -> void
+    def promise: (Stream parent, Enumerable[header_pair] headers, frame_control_flags flags) { (Stream) -> void } -> void
   end
 end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.1.3 → http-2-1.2.0}/sig/stream.rbs

@@ -37,7 +37,7 @@ module HTTP2
 
     def calculate_content_length: (Integer?) -> void
 
-    def send: (frame frame) -> void
+    def send: (stream_frame_props frame) -> void
 
     def headers: (Enumerable[header_pair] headers, ?end_headers: bool, ?end_stream: bool) -> void
 
@@ -70,7 +70,7 @@ module HTTP2
       ?state: Symbol
     ) -> untyped
 
-    def transition: (frame, bool sending) -> void
+    def transition: (stream_frame_props frame, bool sending) -> void
 
     def event: (Symbol newstate) -> void
 
@@ -80,15 +80,14 @@ module HTTP2
 
     def complete_transition: (frame) -> void
 
-    def process_priority: (priority_frame frame) -> void
+    def process_priority: (priority_frame_inner_props frame) -> void
 
-    def end_stream?: (frame frame) -> boolish
+    def end_stream?: (stream_frame_props frame) -> boolish
 
-    def stream_error: (Symbol error, ?msg: String?) -> void
-                    | () -> void
+    def stream_error: (?Symbol error, ?msg: String?) -> void
 
     alias error stream_error
 
-    def manage_state: (frame) { () -> void } -> void
+    def manage_state: (stream_frame_props frame) { () -> void } -> void
   end
-end
+end

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.8.0/doc/release_notes/1_8_0.md

@@ -0,0 +1,100 @@
+# 1.8.0
+
+## Features
+
+### New plugins
+
+#### `:server_sent_events` plugin
+
+The `:server_sent_events` plugin provides a convenience API to deal with `text/event-stream` requests, on top of the `:stream` plugin.
+
+```ruby
+session = HTTPX.plugin(:server_sent_events)
+
+sse_response = session.get("https://example.com/event-stream", event_stream: true)
+
+sse_response.each_message do |message|
+  puts message.id
+  puts message.event
+  puts message.data
+end
+```
+
+You can read more about it in https://gitlab.com/os85/httpx/wikis/Server-Sent-Events .
+
+#### `:cache` plugin
+
+The `:cache` plugin allows caching responses. It exposes some options to determine some of its functionality, i.e. whether a request can use a cached response, whether a response can be cached, whether a cached response is still valid, etc.
+
+This functionality was extracted from the `:response_cache` plugin, which now uses it under the hood.
+
+You can read more about it in https://gitlab.com/os85/httpx/wikis/Cache .
+
+#### `:ntlm_v2_auth` plugin
+
+The `:ntlm_v2_auth` plugin is now available. It implements the most recent version of the NTLM authentication scheme supported by Microsoft products.
+
+You can read more about it in https://gitlab.com/os85/httpx/wikis/Auth#ntlm-v2-auth .
+
+### New timeouts
+
+#### `:total_request_timeout`
+
+You can use the `:total_request_timeout` to time the time it takes a request to get its final response. This includes when your requests follows redirects (via the `:follow_redirects` plugin) or is retried multiple times (via the `:retries´ plugin).
+
+#### `:ping_timeout`
+
+Defines the number of seconds a connection waits to receive a ping response when probing for a connection for liveness.
+
+Defaults to 2 seconds.
+
+### `:ssrf_filter` plugin new options
+
+#### `:extra_unsafe_ranges`
+
+A list of extra unsafe IPs or IP ranges to the default deny list.
+
+#### `:safe_private_ranges`
+
+A list of IPs or IP ranges which are allowed and would otherwise be denied.
+
+### `:auth` plugin new option
+
+#### `:reset_auth_header_expires_in/at`
+
+The `:reset_auth_header_expires_in` and `:reset_auth_header_expires_at`  options enable discarding an authorization token an X number of seconds after it has been generated, or at a particuar point in time, respectively. This is useful when the token is dynamically generated, so that you can preemptively renegotiate a new one.
+
+The `:oauth` plugin makes use of these fields, alongside the `expires_in` claim from token responses, to refresh the token as soon as the it expires.
+
+### `:max_response_body_size`
+
+Can be set to the maximum number of bytes a response may have, after which it'll return an `HTTPX::ErrorResponse`. The limit is enforced based on the `content-length` header and as bytes are received.
+
+### `:max_response_headers`
+
+Can be set to the maximum number of headers a response may have.
+
+### `:max_response_header_value_size`
+
+Can be set to the maximum number of bytes a header value may have. In cases where a header field may be spread across multiple entries (ex. `"cookie"`), the limit is enforced on the aggregate byte size.
+
+### resolver file cache
+
+By specifying `:file` as the resolver `:cache` option, the DNS entries will be cached in a known location in your file system. This will allow sharing entries across processes within the same machine to reduce overall DNS traffic. You can use it via:
+
+```ruby
+session = HTTPX.with(resolver_options: { cache: :file })
+session.get("https://example.com")
+```
+
+## Improvements
+
+* `http-2` minimum version is now 1.2.0, which brings performance benefits around frame parsing and other common operations.
+
+## Bugfixes
+
+* several fixes to make `httpx` usable inside a fiber scheduler in ruby 4.
+* `:proxy` plugin: unescape user/password from proxy options before reusing it (to avoid using percent-encoded values when p.ex. generating base64-encoding for basic auth).
+* `:retries` plugin: fixed the polynomial and exponential backoff `:retry_after` strategies calculation.
+* `:tracing` plugin: fixing span start time set up when request is sent to a closed connection, or when a long-lived connection will be probed for liveness.
+* datadog adapter: fixed integration with the `datadog` gem v2.34 or higher.

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.7.8 → httpx-1.8.0}/lib/httpx/adapters/datadog.rb

@@ -15,8 +15,10 @@ module Datadog::Tracing
 
       TAG_BASE_SERVICE = if Gem::Version.new(DATADOG_VERSION::STRING) < Gem::Version.new("1.15.0")
         "_dd.base_service"
-      else
+      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

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.7.8 → httpx-1.8.0}/lib/httpx/connection/http1.rb

@@ -14,6 +14,7 @@ module HTTPX
       "www-authenticate" => "WWW-Authenticate",
       "http2-settings" => "HTTP2-Settings",
       "content-md5" => "Content-MD5",
+      "last-event-id" => "Last-Event-ID",
     }.freeze
     attr_reader :pending, :requests
 
@@ -23,7 +24,7 @@ module HTTPX
       @options = options
       @max_concurrent_requests = @options.max_concurrent_requests || MAX_REQUESTS
       @max_requests = @options.max_requests
-      @parser = Parser::HTTP1.new(self)
+      @parser = Parser::HTTP1.new(self, options.max_response_headers, options.max_response_header_value_size)
       @buffer = buffer
       @version = [1, 1]
       @pending = []
@@ -47,6 +48,10 @@ module HTTPX
     end
 
     def reset
+      if @ping_timer
+        @ping_timer.cancel
+        @ping_timer = nil
+      end
       @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
       @handshake_completed = false
@@ -132,6 +137,10 @@ module HTTPX
       request.log(color: :yellow) { "-> HEADLINE: #{response.status} HTTP/#{@parser.http_version.join(".")}" }
       request.log(color: :yellow) { response.headers.each.map { |f, v| "-> HEADER: #{f}: #{log_redact_headers(v)}" }.join("\n") }
 
+      if response.content_length && response.content_length > request.options.max_response_body_size
+        raise HTTPX::Error, "maximum response body size exceeded"
+      end
+
       request.response = response
       on_complete if response.finished?
     end