restify 1.15.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95d9cf12fd58e2f17bd1d3c046dfda23eaa38ec2fb99fe0c9b7e1034e014cd1f
-  data.tar.gz: b995cf5d935ba1c83b403fedf18d4c35154ea0ad60d4be0437fa98c89281d687
+  metadata.gz: 85964ce70270ead0fcc3271b733611bcb97f8415e03a91b46cb402032a4c68f5
+  data.tar.gz: 0c99e59283131de272b9a2a1ad23589395bb89e5b8753e330f305e7ec1483685
 SHA512:
-  metadata.gz: 96b5f22cc74ca967876f2ecc86bf30c70fa21ceee6f8726117862ad0e94a6319a9384673cd83a4222bd40b49f4b6eeb48cdec7bd5d1e94ac70fcdab787a8ed5b
-  data.tar.gz: 98199df1ecf1b9467b609ae57f58f2ae459f42f7121c1947763a9d49acb7224d6b8dc50088e74cd7f563719fb81f507d88fca2252a823856e57bbf995db5cbbe
+  metadata.gz: 58bf934808c55172f28ec0673f543531c935b68e8e1f8fcf62435b49dfd7ab2e13522ef6c8b675fbfaf234be7ebfac4fdbfe05d57da4e97288b3876000a2487f
+  data.tar.gz: 4617aa58aa9ba400e1f28a0e5a854c5b56a560abb818432211958295e695feab6fe4bfeb0b5bd6418b231260db778804f4cf5309a34f8d1db9cb501d5f48fe6b

data/CHANGELOG.md

@@ -1,12 +1,12 @@
 # Changelog
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-
-
 ## Unreleased
+
 ---
 
 ### New
@@ -17,164 +17,251 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Breaks
 
+## 2.0.0 - (2025-02-14)
+
+---
+
+### New
+
+- Support for Ruby 3.4
+- Experimental support for OpenTelemetry tracing
+
+### Changes
+
+- Strict keyword handling for request methods
+
+  All request methods take parameters and headers as explicit keyword arguments, not as secondary arguments anymore. Change e.g. `get({}, {headers: ...})` into `get(headers: ...)`, and `head(params)` to `head(params:)`.
+
+  `#post`, `#put`, and `#patch` still take an optional first positional data/body argument. Change `post(body, {}, {headers: ...})` to `post(body, headers: ...)`.
+
+  `#get`, `#head`, and `#delete` accept a hash as the first positional argument, which is merged with `params:`. Therefore, passing parameters as data works too: `get({id: 1})`.
+
+### Breaks
+
+- Remove indifferent access methods (Hashie) from responses
+- Removed `em` and `em-pooled` adapters
+- Require Ruby 3.1+
+
+## 1.15.2 - (2021-12-23)
+
+---
+
+### Fixes
+
+- ActiveSupport v7.0 issues with cache module
 
 ## 1.15.1 - (2021-07-15)
+
 ---
 
 ### Fixes
-* Typhoeus internal exception when request timed out
 
+- Typhoeus internal exception when request timed out
 
 ## 1.15.0 - (2021-07-09)
+
 ---
 
 ### New
-* Improve memory usage when running lots of requests with typhoeus adapter
-* Use hydra for synchronous requests
-* Increased thread stability of typhoeus adapter (new internal queuing mechanism)
+
+- Improve memory usage when running lots of requests with typhoeus adapter
+- Use hydra for synchronous requests
+- Increased thread stability of typhoeus adapter (new internal queuing mechanism)
 
 ### Changes
-* Use Ruby 2.5 as baseline for testing and linting
-* Add Ruby 3.0 to automated testing
-* Changed timing behavior for multiple requests due to new internal queuing mechanism for the typhoeus adapter
 
+- Use Ruby 2.5 as baseline for testing and linting
+- Add Ruby 3.0 to automated testing
+- Changed timing behavior for multiple requests due to new internal queuing mechanism for the typhoeus adapter
 
 ## 1.14.0 - (2020-12-15)
+
 ---
 
 ### New
-* Allow making requests with non-JSON bodies and custom content types (#42)
 
+- Allow making requests with non-JSON bodies and custom content types (#42)
 
 ## 1.13.0 - (2020-06-12)
+
 ---
 
 ### New
-* typhoeus: Support setting per-request libcurl options on adapter
-* typhoeus: Enable short TCP keepalive probes by default (5s/5s)
 
+- typhoeus: Support setting per-request libcurl options on adapter
+- typhoeus: Enable short TCP keepalive probes by default (5s/5s)
 
 ## 1.12.0 - (2020-04-01)
+
 ---
 
 ### Added
-* Explicit exception class for HTTP status code 410 (Gone)
+
+- Explicit exception class for HTTP status code 410 (Gone)
 
 ### Changed
 
 ### Fixed
-* `GatewayError` exception classes introduced in v1.11.0 now properly inherit from `ServerError` (#30)
 
+- `GatewayError` exception classes introduced in v1.11.0 now properly inherit from `ServerError` (#30)
 
 ## 1.11.0 - (2019-07-11)
+
 ### Added
-* Explicit exception classes for HTTP status codes 500, 502, 503, 504
+
+- Explicit exception classes for HTTP status codes 500, 502, 503, 504
 
 ## 1.10.0 - 2018-12-11
+
 ### Changed
+
 - Raise more specific error on a few status codes (#17)
 - Complete promises with an empty list (but a list) of dependencies (#18)
 
 ## 1.9.0 - 2018-11-13
+
 ### Changed
+
 - Do not raise error on 3XX responses but return responses
 
 ## 1.8.0 - 2018-08-22
+
 ### Added
+
 - Add HEAD request method (#16)
 
 ## 1.7.0 - 2018-08-15
+
 ### Added
+
 - Introduce promise dependency timeouts (#15)
 
 ## 1.6.0 - 2018-08-09
+
 ### Changed
+
 - Specify headers on restify clients and individual requests (#14)
 
 ## 1.5.0 - 2018-07-31
+
 ### Added
+
 - Add MessagePack processor enabled by default
 
 ### Changed
+
 - Tune typhoeus adapter to be more race-condition resilent
 
 ## 1.4.4 - 2018-07-13
+
 ### Added
+
 - Add `#request` to `NetworkError` to ease debugging
 
 ### Changed
+
 - Fix race condition in typhoeus adapter
 
 ## 1.4.3 - 2017-11-15
+
 ### Added
+
 - Add advanced logging capabilities using logging gem
 
 ### Changed
+
 - Improve compatibility with webmocks returning `nil` as headers
 
 ## 1.4.1 - 2017-11-15
+
 ### Changed
+
 - Fix possible deadlock issues
 
 ## 1.4.0 - 2017-11-10
+
 ### Added
+
 - Add timeout option to requests (only supported by typhoeus adapter)
 
 ### Changed
+
 - Fix possible concurrency issue with typhoeus adapter
 
 ## 1.3.1 - 2017-11-10
+
 ### Changed
+
 - Improve typhoeus adapters initial request queuing
 - Disable default pipelining
 
 ## 1.3.0 - 2017-11-08
+
 ### Changed
+
 - Improve typhoeus adapter to better utilize concurrency
 - Default to new typhoeus adapter
 
 ## 1.2.1 - 2017-10-30
+
 ### Changed
+
 - Fix issue with Ruby 2.2 compatibility
 
 ## 1.2.0 - 2017-10-30
+
 ### Added
+
 - Add experimental PooledEM adapter (#10)
 
 ### Changed
+
 - Improve marshaling of resources
 
 ## 1.1.0 - 2017-05-12
+
 ### Added
+
 - Add shortcuts for creating fulfilled / rejected promises (#6)
 
 ### Changed
+
 - Return response body if no processor matches (#7)
 
 ## 1.0.0 - 2016-08-22
+
 ### Added
+
 - Experimental cache API doing nothing for now
 
 ### Changed
+
 - Use `~> 1.0` of `concurrent-ruby`
 
 ## 0.5.0 - 2016-04-04
+
 ### Added
+
 - Add `sync` option to typhoeus adapter
 - Add registry for storing entry points
 
 ### Changed
+
 - Make eventmachine based adapter default
 
 ## 0.4.0 - 2016-02-24
+
 ### Added
+
 - Add method to explicit access resource data
 
 ### Changed
+
 - Use typhoeus as default adapter
 - `Restify.new` returns relation now instead of resource
 
 ### Removed
+
 - Drop obligation in favor of simple Concurrent::IVar based promise class.
   Notable changes:
   - Returned object us of type `Restify::Promise` now.

data/README.md

@@ -1,7 +1,8 @@
 # Restify
 
-[![Build Status](https://travis-ci.org/jgraichen/restify.svg?branch=master)](https://travis-ci.org/jgraichen/restify)
-[![Code Quality](https://codebeat.co/badges/18ffe6b7-8239-493a-b5b6-be329b9f275d)](https://codebeat.co/projects/github-com-jgraichen-restify-master)
+[![Gem Version](https://img.shields.io/gem/v/restify?logo=ruby)](https://rubygems.org/gems/restify)
+[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/jgraichen/restify/test.yml?logo=github)](https://github.com/jgraichen/restify/actions)
+[![Code Quality](https://codebeat.co/badges/368f8033-bd76-48bc-9777-85f1d4befa94)](https://codebeat.co/projects/github-com-jgraichen-restify-main)
 
 Restify is an hypermedia REST client that does parallel, concurrent and keep-alive requests by default.
 
@@ -27,16 +28,19 @@ Links are extracted from
 * HTTP Link header
 * Github-style relations in payloads
 
-### Planned features
+## Installation
 
-* HTTP cache
-* API versions via header
-* Content-Type and Language negotiation
-* Processors for JSON-HAL, etc.
+Add it to your Gemfile:
 
-## Installation
+```ruby
+gem 'restify', '~> 2.0'
+```
 
-Add it to your Gemfile or install it manually: `$ gem install restify`
+Or install it manually:
+
+```console
+gem install restify
+```
 
 ## Usage
 
@@ -51,7 +55,7 @@ client = Restify.new('https://api.github.com').get.value
 # ...
 ```
 
-We are essentially requesting `'http://api.github.com'` via HTTP `get`. `get` is returning an `Promise`, similar to Java's `Future`. The `value` call resolves the returned `Promise` by blocking the thread until the resource is actually there. `value!` will additionally raise errors instead of returning `nil`. You can chain handlers using the `then` method. This allows you to be build a dependency chain that will be executed when the last promise is needed.
+We are essentially requesting `'http://api.github.com'` via HTTP `get`. `get` is returning a `Promise`, similar to Java's `Future`. The `value` call resolves the returned `Promise` by blocking the thread until the resource is actually there. `value!` will additionally raise errors instead of returning `nil`. You can chain handlers using the `then` method. This allows you to be build a dependency chain that will be executed when the last promise is needed.
 
 As we can see GitHub returns us a field `repository_url` with a URI template. Restify automatically scans for `*_url` fields in the JSON response and exposes these as relations. It additionally scans the HTTP Header field `Link` for relations like pagination.
 
@@ -65,33 +69,21 @@ repositories = client.rel(:repository)
 This gets us the relation named `repository` that we can request now. The usual HTTP methods are available on a relation:
 
 ```ruby
-    def get(params = {})
-      request :get, nil, params
-    end
-
-    def delete(params = {})
-      request :delete, nil, params
-    end
-
-    def post(data = {}, params = {})
-      request :post, data, params
-    end
-
-    def put(data = {}, params = {})
-      request :put, data, params
-    end
+def get(params, params:, headers:, **)
+def head(params, params:, headers:, **)
+def delete(params, params:, headers:, **)
 
-    def patch(data = {}, params = {})
-      request :patch, data, params
-    end
+def put(data = nil, params:, headers:, **)
+def post(data = nil, params:, headers:, **)
+def patch(data = nil, params:, headers:, **)
 ```
 
-URL templates can define some parameters such as `{owner}` or `{repo}`. They will be expanded from the `params` given to the HTTP method method.
+URL templates can define some parameters such as `{owner}` or `{repo}`. They will be expanded from the `params` given to the HTTP method.
 
 Now send a GET request with some parameters to request a specific repository:
 
 ```ruby
-repo = repositories.get(owner: 'jgraichen', repo: 'restify').value
+repo = repositories.get({owner: 'jgraichen', repo: 'restify'}).value
 ```
 
 Now fetch a list of commits for this repo and get this first one:
@@ -121,7 +113,7 @@ See commented example in main spec [`spec/restify_spec.rb`](https://github.com/j
 
 ## License
 
-Copyright (C) 2014-2018 Jan Graichen
+Copyright (C) 2014-2025 Jan Graichen
 
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
 

data/lib/restify/adapter/base.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require 'restify/adapter/telemetry'
+
 module Restify
   module Adapter
     class Base
+      prepend Telemetry
+
       def call(request)
         Promise.create do |writer|
           call_native request, writer

data/lib/restify/adapter/telemetry.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'opentelemetry'
+require 'opentelemetry/common'
+
+module Restify
+  module Adapter
+    module Telemetry
+      def call(request)
+        method = request.method.to_s.upcase
+        uri = URI.parse(request.uri)
+        name = "#{method} #{uri.scheme}://#{uri.host}:#{uri.port}"
+
+        attributes = {
+          'http.request.method' => method,
+          'server.address' => uri.host,
+          'server.port' => uri.port,
+          'url.full' => uri.to_s,
+          'url.scheme' => uri.scheme,
+        }
+
+        span = tracer.start_span(name, attributes:, kind: :client)
+        OpenTelemetry::Trace.with_span(span) do
+          OpenTelemetry.propagation.inject(request.headers)
+
+          super.tap do |x|
+            x.add_observer do |_, response, err|
+              if response
+                span.set_attribute('http.response.status_code', response&.code)
+                span.status = OpenTelemetry::Trace::Status.error unless (100..399).cover?(response&.code)
+              end
+
+              span.status = OpenTelemetry::Trace::Status.error(err) if err
+
+              span.finish
+            end
+          end
+        end
+      end
+
+      protected
+
+      def tracer
+        Telemetry.tracer
+      end
+
+      class << self
+        def tracer
+          @tracer ||= OpenTelemetry.tracer_provider.tracer('restify', Restify::VERSION.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/restify/adapter/typhoeus.rb

@@ -2,7 +2,7 @@
 
 require 'typhoeus'
 
-::Ethon.logger = ::Logging.logger[Ethon]
+Ethon.logger = Logging.logger[Ethon]
 
 module Restify
   module Adapter
@@ -13,18 +13,36 @@ module Restify
 
       DEFAULT_HEADERS = {
         'Expect' => '',
-        'Transfer-Encoding' => ''
+        'Transfer-Encoding' => '',
       }.freeze
 
       DEFAULT_OPTIONS = {
         followlocation: true,
         tcp_keepalive: true,
         tcp_keepidle: 5,
-        tcp_keepintvl: 5
+        tcp_keepintvl: 5,
       }.freeze
 
+      # Patch to store easy handles in the queue, instead of requests.
+      # This improves compatibility with OpenTelemetry instrumentation
+      # for Ethon, that needs the request handle to be constructed in
+      # the current threading context, not the background thread were
+      # Typhoeus is running.
+      module EasyOverride
+        def queue(request)
+          request.hydra = self
+          queued_requests << ::Typhoeus::EasyFactory.new(request, self).get
+        end
+
+        def add(handle)
+          multi.add(handle)
+        end
+      end
+
       def initialize(sync: false, options: {}, **kwargs)
-        @hydra   = ::Typhoeus::Hydra.new(**kwargs)
+        @hydra = ::Typhoeus::Hydra.new(**kwargs)
+        @hydra.extend(EasyOverride)
+
         @mutex   = Mutex.new
         @options = DEFAULT_OPTIONS.merge(options)
         @queue   = Queue.new
@@ -38,7 +56,6 @@ module Restify
         @sync
       end
 
-      # rubocop:disable Metrics/MethodLength
       def call_native(request, writer)
         req = convert(request, writer)
 
@@ -57,12 +74,9 @@ module Restify
           thread.run unless thread.status
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
       private
 
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/MethodLength
       def convert(request, writer)
         ::Typhoeus::Request.new(
           request.uri,
@@ -71,7 +85,7 @@ module Restify
           headers: DEFAULT_HEADERS.merge(request.headers),
           body: request.body,
           timeout: request.timeout,
-          connecttimeout: request.timeout
+          connecttimeout: request.timeout,
         ).tap do |req|
           req.on_complete do |response|
             debug 'request:complete',
@@ -93,8 +107,6 @@ module Restify
           end
         end
       end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/AbcSize
 
       def convert_back(response, request)
         uri     = request.uri
@@ -108,7 +120,7 @@ module Restify
       def convert_headers(headers)
         return {} unless headers.respond_to?(:each_pair)
 
-        headers.each_pair.each_with_object({}) do |header, memo|
+        headers.each_pair.with_object({}) do |header, memo|
           memo[header[0].upcase.tr('-', '_')] = header[1]
         end
       end
@@ -127,7 +139,6 @@ module Restify
         @thread
       end
 
-      # rubocop:disable Metrics/MethodLength
       def run
         runs = 0
 
@@ -154,7 +165,6 @@ module Restify
       ensure
         debug 'hydra:exit'
       end
-      # rubocop:enable Metrics/MethodLength
 
       def dequeue_all
         loop do

data/lib/restify/context.rb

@@ -47,26 +47,22 @@ module Restify
       processor.new(context, response).resource
     end
 
-    # rubocop:disable Metrics/MethodLength
     def request(method, uri, data: nil, headers: {}, **kwargs)
       request = Request.new(
         headers: default_headers.merge(headers),
         **kwargs,
-        method: method,
+        method:,
         uri: join(uri),
-        data: data
+        data:,
       )
 
       ret = cache.call(request) {|req| adapter.call(req) }
       ret.then do |response|
-        if response.errored?
-          raise ResponseError.from_code(response)
-        else
-          process response
-        end
+        raise ResponseError.from_code(response) if response.errored?
+
+        process(response)
       end
     end
-    # rubocop:enable all
 
     def encode_with(coder)
       coder.map = marshal_dump
@@ -79,12 +75,12 @@ module Restify
     def marshal_dump
       {
         uri: uri.to_s,
-        headers: default_headers
+        headers: default_headers,
       }
     end
 
     def marshal_load(dump)
-      initialize dump.delete(:uri), \
+      initialize dump.delete(:uri),
         headers: dump.fetch(:headers)
     end
 

data/lib/restify/error.rb

@@ -55,8 +55,8 @@ module Restify
 
     def initialize(response)
       @response = response
-      super "#{response.message} (#{response.code}) for `#{response.uri}':\n" \
-            "  #{errors.inspect}"
+      super("#{response.message} (#{response.code}) for `#{response.uri}':\n  " \
+            "#{errors.inspect}")
     end
 
     # Return response status.

data/lib/restify/global.rb

@@ -20,6 +20,7 @@ module Restify
 
     def cache
       @cache ||= begin
+        require 'active_support'
         require 'active_support/cache'
         Restify::Cache.new store: ActiveSupport::Cache::MemoryStore.new
       end

data/lib/restify/link.rb

@@ -25,10 +25,10 @@ module Restify
     end
 
     class << self
-      REGEXP_URI = /<[^>]*>\s*/.freeze
-      REGEXP_PAR = /;\s*\w+\s*=\s*/i.freeze
-      REGEXP_QUT = /"[^"]*"\s*/.freeze
-      REGEXP_ARG = /\w+\s*/i.freeze
+      REGEXP_URI = /<[^>]*>\s*/
+      REGEXP_PAR = /;\s*\w+\s*=\s*/i
+      REGEXP_QUT = /"[^"]*"\s*/
+      REGEXP_ARG = /\w+\s*/i
 
       def parse(string)
         scanner = StringScanner.new(string.strip)

data/lib/restify/logging.rb

@@ -14,7 +14,7 @@ module Restify
           _log_prefix,
           *Array(tag),
           message,
-          _fmt(**kwargs)
+          _fmt(**kwargs),
         ].map(&:to_s).reject(&:empty?).join(' ')
       end
     end