restify 1.15.2 → 2.0.1

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: restify
 version: !ruby/object:Gem::Version
-  version: 1.15.2
+  version: 2.0.1
 platform: ruby
 authors:
 - Jan Graichen
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-23 00:00:00.000000000 Z
+date: 2025-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -52,26 +51,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: hashie
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.3'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.3'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: hitimes
   requirement: !ruby/object:Gem::Requirement
@@ -115,51 +94,65 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: opentelemetry-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: typhoeus
+  name: opentelemetry-common
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: An experimental hypermedia REST client that uses parallel, keep-alive
   and pipelined requests by default.
 email:
-- jg@altimos.de
+- jgraichen@altimos.de
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -167,10 +160,10 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- doc/file.README.html
 - lib/restify.rb
 - lib/restify/adapter/base.rb
-- lib/restify/adapter/em.rb
-- lib/restify/adapter/pooled_em.rb
+- lib/restify/adapter/telemetry.rb
 - lib/restify/adapter/typhoeus.rb
 - lib/restify/cache.rb
 - lib/restify/context.rb
@@ -194,10 +187,12 @@ files:
 - spec/restify/context_spec.rb
 - spec/restify/error_spec.rb
 - spec/restify/features/head_requests_spec.rb
+- spec/restify/features/opentelemetry_spec.rb
 - spec/restify/features/request_bodies_spec.rb
 - spec/restify/features/request_errors_spec.rb
 - spec/restify/features/request_headers_spec.rb
 - spec/restify/features/response_errors_spec.rb
+- spec/restify/features/webmock_spec.rb
 - spec/restify/global_spec.rb
 - spec/restify/link_spec.rb
 - spec/restify/processors/base_spec.rb
@@ -210,13 +205,13 @@ files:
 - spec/restify/timeout_spec.rb
 - spec/restify_spec.rb
 - spec/spec_helper.rb
+- spec/support/opentelemetry.rb
 - spec/support/stub_server.rb
 homepage: https://github.com/jgraichen/restify
 licenses:
 - LGPL-3.0+
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -224,36 +219,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: An experimental hypermedia REST client.
-test_files:
-- spec/restify/cache_spec.rb
-- spec/restify/context_spec.rb
-- spec/restify/error_spec.rb
-- spec/restify/features/head_requests_spec.rb
-- spec/restify/features/request_bodies_spec.rb
-- spec/restify/features/request_errors_spec.rb
-- spec/restify/features/request_headers_spec.rb
-- spec/restify/features/response_errors_spec.rb
-- spec/restify/global_spec.rb
-- spec/restify/link_spec.rb
-- spec/restify/processors/base_spec.rb
-- spec/restify/processors/json_spec.rb
-- spec/restify/processors/msgpack_spec.rb
-- spec/restify/promise_spec.rb
-- spec/restify/registry_spec.rb
-- spec/restify/relation_spec.rb
-- spec/restify/resource_spec.rb
-- spec/restify/timeout_spec.rb
-- spec/restify_spec.rb
-- spec/spec_helper.rb
-- spec/support/stub_server.rb
+test_files: []

data/lib/restify/adapter/em.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'eventmachine'
-require 'em-http-request'
-
-module Restify
-  module Adapter
-    class EM < Base
-      class Connection
-        class << self
-          def open(uri)
-            connections[uri.origin] ||= new uri.origin
-          end
-
-          def connections
-            @connections ||= {}
-          end
-        end
-
-        attr_reader :origin
-
-        def initialize(origin)
-          @origin   = origin
-          @pipeline = true
-        end
-
-        def requests
-          @requests ||= []
-        end
-
-        # rubocop:disable Style/IdenticalConditionalBranches
-        def call(request, writer, retried: false)
-          if requests.empty?
-            requests << [request, writer, retried]
-            process_next
-          else
-            requests << [request, writer, retried]
-          end
-        end
-        # rubocop:enable all
-
-        def connection
-          @connection ||= EventMachine::HttpRequest.new(origin)
-        end
-
-        def pipeline?
-          @pipeline
-        end
-
-        def process_next
-          return if requests.empty?
-
-          request, writer, retried = pipeline? ? requests.shift : requests.first
-          begin
-            req = connection.send request.method.downcase,
-              keepalive: true,
-              redirects: 3,
-              path: request.uri.normalized_path,
-              query: request.uri.normalized_query,
-              body: request.body,
-              head: request.headers
-          rescue Exception => e # rubocop:disable Lint/RescueException
-            writer.reject e
-            requests.shift unless pipeline?
-            return
-          end
-
-          req.callback do
-            requests.shift unless pipeline?
-
-            writer.fulfill Response.new(
-              request,
-              req.last_effective_url,
-              req.response_header.status,
-              req.response_header,
-              req.response,
-            )
-
-            if req.response_header['CONNECTION'] == 'close'
-              @connection = nil
-              @pipeline   = false
-            end
-
-            process_next
-          end
-
-          req.errback do
-            requests.shift unless pipeline?
-            @connection = nil
-
-            if pipeline?
-              EventMachine.next_tick do
-                @pipeline = false
-                call request, writer
-              end
-            elsif !retried
-              EventMachine.next_tick { call request, writer }
-            else
-              begin
-                raise "(#{req.response_header.status}) #{req.error}"
-              rescue StandardError => e
-                writer.reject e
-              end
-            end
-          end
-        end
-      end
-
-      def call_native(request, writer)
-        next_tick do
-          Connection.open(request.uri).call(request, writer)
-        end
-      end
-
-      private
-
-      def next_tick(&block)
-        ensure_running
-        EventMachine.next_tick(&block)
-      end
-
-      def ensure_running
-        return if EventMachine.reactor_running?
-
-        Thread.new do
-          EventMachine.run
-        rescue StandardError => e
-          puts "#{self.class} -> #{e}\n#{e.backtrace.join("\n")}"
-          raise e
-        end
-      end
-    end
-  end
-end

data/lib/restify/adapter/pooled_em.rb

@@ -1,269 +0,0 @@
-# frozen_string_literal: true
-
-require 'eventmachine'
-require 'em-http-request'
-
-module Restify
-  module Adapter
-    class PooledEM < Base
-      include Logging
-
-      # This class maintains a pool of connection objects, grouped by origin,
-      # and ensures limits for total parallel requests and per-origin requests.
-      #
-      # It does so by maintaining a list of already open, reusable connections.
-      # When any of them are checked out for usage, it counts the usages to
-      # prevent constraints being broken.
-      class Pool
-        include Logging
-
-        def initialize(size: 32, per_host: 6, connect_timeout: 2, inactivity_timeout: 10)
-          @size = size
-          @per_host = per_host
-          @connect_timeout = connect_timeout
-          @inactivity_timeout = inactivity_timeout
-
-          @host = Hash.new {|h, k| h[k] = 0 }
-          @available = []
-          @queue = []
-          @used = 0
-        end
-
-        # Request a connection from the pool.
-        #
-        # Attempts to checkout a reusable connection from the pool (or create a
-        # new one). If any of the limits have been reached, the request will be
-        # put onto a queue until other connections are released.
-        #
-        # Returns a Deferrable that succeeds with a connection instance once a
-        # connection has been checked out (usually immediately).
-        #
-        # @return [Deferrable<Request>]
-        #
-        def get(request, timeout: 2)
-          defer = Deferrable.new(request)
-          defer.timeout(timeout, :timeout)
-          defer.errback { @queue.delete(defer) }
-
-          checkout(defer)
-
-          defer
-        end
-
-        # Return a connection to the pool.
-        #
-        # If there are requests in the queue (due to one of the limits having
-        # been reached), they will be given an attempt to use the released
-        # connection.
-        #
-        # If no requests are queued, the connection will be held for reuse by a
-        # subsequent request.
-        #
-        # @return [void]
-        #
-        def release(conn)
-          @available.unshift(conn) if @available.size < @size
-          @used -= 1 if @used.positive?
-
-          logger.debug do
-            "[#{conn.uri}] Released to pool (#{@available.size}/#{@used}/#{size})"
-          end
-
-          checkout(@queue.shift) if @queue.any? # checkout next waiting defer
-        end
-
-        alias << release
-
-        def remove(conn)
-          close(conn)
-
-          logger.debug do
-            "[#{conn.uri}] Removed from pool (#{@available.size}/#{@used}/#{size})"
-          end
-
-          checkout(@queue.shift) if @queue.any? # checkout next waiting defer
-        end
-
-        # Determine the number of connections in the pool.
-        #
-        # This takes into account both reusable (idle) and used connections.
-        #
-        # @return [Integer]
-        #
-        def size
-          @available.size + @used
-        end
-
-        private
-
-        def close(conn)
-          @used -= 1 if @used.positive?
-          @host[conn.uri.to_s] -= 1
-
-          conn.close
-        end
-
-        def checkout(defer)
-          origin = defer.request.uri.origin
-
-          if (index = find_reusable_connection(origin))
-            defer.succeed reuse_connection(index, origin)
-          elsif can_build_new_connection?(origin)
-            defer.succeed new_connection(origin)
-          else
-            queue defer
-          end
-        end
-
-        def find_reusable_connection(origin)
-          @available.find_index {|conn| conn.uri == origin }
-        end
-
-        def reuse_connection(index, origin)
-          @used += 1
-          @available.delete_at(index).tap do
-            logger.debug do
-              "[#{origin}] Take connection from pool " \
-                "(#{@available.size}/#{@used}/#{size})"
-            end
-          end
-        end
-
-        def new_connection(origin)
-          # If we have reached the limit, we have to throw away the oldest
-          # reusable connection in order to open a new one
-          close_oldest if size >= @size
-
-          @used += 1
-          new(origin).tap do
-            logger.debug do
-              "[#{origin}] Add new connection to pool " \
-                "(#{@available.size}/#{@used}/#{size})"
-            end
-          end
-        end
-
-        def close_oldest
-          close(@available.pop)
-
-          logger.debug do
-            "[#{origin}] Closed oldest connection in pool " \
-              "(#{@available.size}/#{@used}/#{size})"
-          end
-        end
-
-        def queue(defer)
-          logger.debug do
-            "[#{origin}] Wait for free slot " \
-              "(#{@available.size}/#{@used}/#{size})"
-          end
-
-          @queue << defer
-        end
-
-        def new(origin)
-          logger.debug do
-            "Connect to '#{origin}' " \
-              "(#{@connect_timeout}/#{@inactivity_timeout})..."
-          end
-
-          @host[origin] += 1
-
-          EventMachine::HttpRequest.new origin,
-            connect_timeout: @connect_timeout,
-            inactivity_timeout: @inactivity_timeout
-        end
-
-        def can_build_new_connection?(origin)
-          return false if @host[origin] >= @per_host
-
-          size < @size || @available.any?
-        end
-
-        class Deferrable
-          include ::EventMachine::Deferrable
-
-          attr_reader :request
-
-          def initialize(request)
-            @request = request
-          end
-
-          def succeed(connection)
-            @connection = connection
-            super
-          end
-        end
-      end
-
-      def initialize(**kwargs)
-        super()
-        @pool = Pool.new(**kwargs)
-      end
-
-      # rubocop:disable Metrics/BlockLength
-      def call_native(request, writer)
-        next_tick do
-          defer = @pool.get(request)
-
-          defer.errback do |error|
-            writer.reject(error)
-          end
-
-          defer.callback do |conn|
-            req = conn.send request.method.downcase,
-              keepalive: true,
-              redirects: 3,
-              path: request.uri.normalized_path,
-              query: request.uri.normalized_query,
-              body: request.body,
-              head: request.headers
-
-            req.callback do
-              writer.fulfill Response.new(
-                request,
-                req.last_effective_url,
-                req.response_header.status,
-                req.response_header,
-                req.response,
-              )
-
-              if req.response_header['CONNECTION'] == 'close'
-                @pool.remove(conn)
-              else
-                @pool << conn
-              end
-            end
-
-            req.errback do
-              @pool.remove(conn)
-              writer.reject(req.error)
-            end
-          rescue Exception => e # rubocop:disable Lint/RescueException
-            @pool.remove(conn)
-            writer.reject(e)
-          end
-        end
-      end
-      # rubocop:enable all
-
-      private
-
-      def next_tick(&block)
-        ensure_running
-        EventMachine.next_tick(&block)
-      end
-
-      def ensure_running
-        return if EventMachine.reactor_running?
-
-        Thread.new do
-          EventMachine.run
-        rescue StandardError => e
-          logger.error(e)
-          raise e
-        end
-      end
-    end
-  end
-end