restify 1.15.2 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c29c95a9b1c0b18f2a73b51c99da7cdddf163e1cee33c43272810f5557b1375b
-  data.tar.gz: 95f956684154058cc6f25b7d4ffebde6706864b00c1369e91c8f8b5fcc50f0d9
+  metadata.gz: 2b3748ffce3669fb7d0cf84c08ef2cb5732e18edd0a2c7f49c611c00a7d09058
+  data.tar.gz: 86918b318d74c3c1fa5ed03e68bd4fcc877a0697b37a324407508a1d2cb78477
 SHA512:
-  metadata.gz: f420cc4d0c4ebbdade1bc1a780c24218b5eea707bd8e420c113d155d58067936464dc3d4807717de8f515ed586784c9f13476b46c66f68c8d1181501937db3a2
-  data.tar.gz: 71da11cdf50d25abc968af02c6157c63f1aa5703c88f7ae28c3394aa028d9f038013d220283510532f7b540dffc69d0abad5fe4952c4e27df4910a4009475ae5
+  metadata.gz: 8fca1f764083979b98c66a55c2a3d49e3ad4c77bff142f2e5af8d40c4003fd2151bb8bce4076cb66b856b91054fba4cb814bb0635d2b3be3cf9d7e6b301f79f2
+  data.tar.gz: bdb52897e18ae8ba441128f9147a383ddde7e777f92ab59cce5353ac8e8feda23c9af072f9aaf2b4cb252085840bb7ef70927b289a42b66e6209a650d3d5a4c5

data/CHANGELOG.md

@@ -5,8 +5,8 @@ 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,6 +17,39 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Breaks
 
+## 2.0.1 - (2025-02-16)
+
+---
+
+### Fixes
+
+- Restore compatibility with WebMocks Typhoeus instrumentation
+- Catch WebMock exception and bubble them to the request promises
+
+## 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)
 
@@ -26,7 +59,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 - ActiveSupport v7.0 issues with cache module
 
-
 ## 1.15.1 - (2021-07-15)
 
 ---

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/doc/file.README.html

@@ -0,0 +1,192 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>
+  File: README
+  
+    &mdash; Documentation by YARD 0.9.37
+  
+</title>
+
+  <link rel="stylesheet" href="css/style.css" type="text/css" />
+
+  <link rel="stylesheet" href="css/common.css" type="text/css" />
+
+<script type="text/javascript">
+  pathId = "README";
+  relpath = '';
+</script>
+
+
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+
+
+  </head>
+  <body>
+    <div class="nav_wrap">
+      <iframe id="nav" src="file_list.html?1"></iframe>
+      <div id="resizer"></div>
+    </div>
+
+    <div id="main" tabindex="-1">
+      <div id="header">
+        <div id="menu">
+  
+    <a href="_index.html">Index</a> &raquo; 
+    <span class="title">File: README</span>
+  
+</div>
+
+        <div id="search">
+  
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+
+        <svg width="24" height="24">
+          <rect x="0" y="4" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="12" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="20" width="24" height="4" rx="1" ry="1"></rect>
+        </svg>
+    </a>
+  
+</div>
+        <div class="clear"></div>
+      </div>
+
+      <div id="content"><div id='filecontents'><h1 id="restify">Restify</h1>
+
+<p><a href="https://rubygems.org/gems/restify"><img src="https://img.shields.io/gem/v/restify?logo=ruby" alt="Gem Version"></a>
+<a href="https://github.com/jgraichen/restify/actions"><img src="https://img.shields.io/github/actions/workflow/status/jgraichen/restify/test.yml?logo=github" alt="GitHub Actions Workflow Status"></a>
+<a href="https://codebeat.co/projects/github-com-jgraichen-restify-main"><img src="https://codebeat.co/badges/368f8033-bd76-48bc-9777-85f1d4befa94" alt="Code Quality"></a></p>
+
+<p>Restify is an hypermedia REST client that does parallel, concurrent and keep-alive requests by default.</p>
+
+<p>Restify scans Link headers and returned resource for links and relations to other resources, represented as RFC6570 URI Templates, and exposes those to the developer.</p>
+
+<p>Restify can be used to consume hypermedia REST APIs (like GitHubs), to build a site-specific library or to use within your own backend services.</p>
+
+<p>Restify is build upon the following libraries:</p>
+
+<ul>
+<li><a href="https://github.com/ruby-concurrency/concurrent-ruby">concurrent-ruby</a></li>
+<li><a href="https://github.com/sporkmonger/addressable">addressable</a></li>
+<li><a href="https://github.com/typhoeus/typhoeus">typhoeus</a></li>
+</ul>
+
+<p>The HTTP adapters are mostly run in a background thread and may not survive mid-application forks.</p>
+
+<p>Restify includes processors to parse responses and to extract links between resources. The following formats are can be parsed:</p>
+
+<ul>
+<li>JSON</li>
+<li>MessagePack</li>
+</ul>
+
+<p>Links are extracted from</p>
+
+<ul>
+<li>HTTP Link header</li>
+<li>Github-style relations in payloads</li>
+</ul>
+
+<h2 id="installation">Installation</h2>
+
+<p>Add it to your Gemfile:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_gem'>gem</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>restify</span><span class='tstring_end'>&#39;</span></span><span class='comma'>,</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>~&gt; 2.0</span><span class='tstring_end'>&#39;</span></span>
+</code></pre>
+
+<p>Or install it manually:</p>
+
+<pre class="code console"><code class="console">gem install restify
+</code></pre>
+
+<h2 id="usage">Usage</h2>
+
+<p>Create new Restify object. It essentially means to request some start-resource usually the &quot;root&quot; resource:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_client'>client</span> <span class='op'>=</span> <span class='const'><span class='object_link'><a href="Restify.html" title="Restify (module)">Restify</a></span></span><span class='period'>.</span><span class='id identifier rubyid_new'><span class='object_link'><a href="Restify/Global.html#new-instance_method" title="Restify::Global#new (method)">new</a></span></span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>https://api.github.com</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_get'>get</span><span class='period'>.</span><span class='id identifier rubyid_value'>value</span>
+<span class='comment'># =&gt; {&quot;current_user_url&quot;=&gt;&quot;https://api.github.com/user&quot;,
+</span><span class='comment'>#     &quot;current_user_authorizations_html_url&quot;=&gt;&quot;https://github.com/settings/connections/applications{/client_id}&quot;,
+</span><span class='comment'># ...
+</span><span class='comment'>#     &quot;repository_url&quot;=&gt;&quot;https://api.github.com/repos/{owner}/{repo}&quot;,
+</span><span class='comment'># ...
+</span></code></pre>
+
+<p>We are essentially requesting <code>&#39;http://api.github.com&#39;</code> via HTTP <code>get</code>. <code>get</code> is returning a <code>Promise</code>, similar to Java&#39;s <code>Future</code>. The <code>value</code> call resolves the returned <code>Promise</code> by blocking the thread until the resource is actually there. <code>value!</code> will additionally raise errors instead of returning <code>nil</code>. You can chain handlers using the <code>then</code> method. This allows you to be build a dependency chain that will be executed when the last promise is needed.</p>
+
+<p>As we can see GitHub returns us a field <code>repository_url</code> with a URI template. Restify automatically scans for <code>*_url</code> fields in the JSON response and exposes these as relations. It additionally scans the HTTP Header field <code>Link</code> for relations like pagination.</p>
+
+<p>We can now use the relations to navigate from resource to resource like a browser from one web page to another page.</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_repositories'>repositories</span> <span class='op'>=</span> <span class='id identifier rubyid_client'>client</span><span class='period'>.</span><span class='id identifier rubyid_rel'>rel</span><span class='lparen'>(</span><span class='symbol'>:repository</span><span class='rparen'>)</span>
+<span class='comment'># =&gt; #&lt;Restify::Relation:0x00000005548968 @context=#&lt;Restify::Context:0x007f6024066ae0 @uri=#&lt;Addressable::URI:0x29d8684 URI:https://api.github.com&gt;&gt;, @template=#&lt;Addressable::Template:0x2aa44a0 PATTERN:https://api.github.com/repos/{owner}/{repo}&gt;&gt;
+</span></code></pre>
+
+<p>This gets us the relation named <code>repository</code> that we can request now. The usual HTTP methods are available on a relation:</p>
+
+<pre class="code ruby"><code class="ruby">def get(params, params:, headers:, **)
+def head(params, params:, headers:, **)
+def delete(params, params:, headers:, **)
+
+def put(data = nil, params:, headers:, **)
+def post(data = nil, params:, headers:, **)
+def patch(data = nil, params:, headers:, **)
+</code></pre>
+
+<p>URL templates can define some parameters such as <code>{owner}</code> or <code>{repo}</code>. They will be expanded from the <code>params</code> given to the HTTP method.</p>
+
+<p>Now send a GET request with some parameters to request a specific repository:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_repo'>repo</span> <span class='op'>=</span> <span class='id identifier rubyid_repositories'>repositories</span><span class='period'>.</span><span class='id identifier rubyid_get'>get</span><span class='lparen'>(</span><span class='lbrace'>{</span><span class='label'>owner:</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>jgraichen</span><span class='tstring_end'>&#39;</span></span><span class='comma'>,</span> <span class='label'>repo:</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>restify</span><span class='tstring_end'>&#39;</span></span><span class='rbrace'>}</span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_value'>value</span>
+</code></pre>
+
+<p>Now fetch a list of commits for this repo and get this first one:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_commit'>commit</span> <span class='op'>=</span> <span class='id identifier rubyid_repo'>repo</span><span class='period'>.</span><span class='id identifier rubyid_rel'>rel</span><span class='lparen'>(</span><span class='symbol'>:commits</span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_get'>get</span><span class='period'>.</span><span class='id identifier rubyid_value'>value</span><span class='period'>.</span><span class='id identifier rubyid_first'>first</span>
+</code></pre>
+
+<p>And print it:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>Last commit: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_commit'>commit</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>sha</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='embexpr_end'>}</span><span class='tstring_end'>&quot;</span></span>
+<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>By </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_commit'>commit</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>commit</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>author</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>name</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='embexpr_end'>}</span><span class='tstring_content'> &lt;</span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_commit'>commit</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>commit</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>author</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>email</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='embexpr_end'>}</span><span class='tstring_content'>&gt;</span><span class='tstring_end'>&quot;</span></span>
+<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_commit'>commit</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>commit</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>message</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='embexpr_end'>}</span><span class='tstring_end'>&quot;</span></span>
+</code></pre>
+
+<p>See commented example in main spec <a href="https://github.com/jgraichen/restify/blob/master/spec/restify_spec.rb#L100"><code>spec/restify_spec.rb</code></a> or in the <code>examples</code> directory.</p>
+
+<h2 id="contributing">Contributing</h2>
+
+<ol>
+<li><a href="http://github.com/jgraichen/restify/fork">Fork it</a></li>
+<li>Create your feature branch (<code>git checkout -b my-new-feature</code>)</li>
+<li>Commit specs for your feature so that I do not break it later</li>
+<li>Commit your changes (<code>git commit -am &#39;Add some feature&#39;</code>)</li>
+<li>Push to the branch (<code>git push origin my-new-feature</code>)</li>
+<li>Create new Pull Request</li>
+</ol>
+
+<h2 id="license">License</h2>
+
+<p>Copyright (C) 2014-2025 Jan Graichen</p>
+
+<p>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.</p>
+
+<p>This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.</p>
+
+<p>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <a href="http://www.gnu.org/licenses/">http://www.gnu.org/licenses/</a>.</p>
+</div></div>
+
+      <div id="footer">
+  Generated on Sun Feb 16 14:11:59 2025 by
+  <a href="https://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.9.37 (ruby-3.4.2).
+</div>
+
+    </div>
+  </body>
+</html>

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
@@ -23,8 +23,28 @@ module Restify
         tcp_keepintvl: 5,
       }.freeze
 
+      # Patch Hydra to restore the correct OpenTelemetry span when
+      # adding the request, so that the Ethon instrumentation can
+      # properly pick up the context where the Restify request
+      # originated from.
+      #
+      # Handle exception from Ethon or WebMock too, and reject the
+      # promise, so that the errors can be handled in user code.
+      # Otherwise, the user would only receive a Promise timeout.
+      module EasyOverride
+        def add(request)
+          OpenTelemetry::Trace.with_span(request._otel_span) do
+            super(request)
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            request._restify_writer.reject(e)
+          end
+        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
@@ -60,7 +80,7 @@ module Restify
       private
 
       def convert(request, writer)
-        ::Typhoeus::Request.new(
+        Request.new(
           request.uri,
           **@options,
           method: request.method,
@@ -69,6 +89,9 @@ module Restify
           timeout: request.timeout,
           connecttimeout: request.timeout,
         ).tap do |req|
+          req._otel_span = OpenTelemetry::Trace.current_span
+          req._restify_writer = writer
+
           req.on_complete do |response|
             debug 'request:complete',
               tag: request.object_id,
@@ -102,7 +125,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
@@ -159,6 +182,16 @@ module Restify
       def _log_prefix
         "[#{object_id}/#{Thread.current.object_id}]"
       end
+
+      class Request < ::Typhoeus::Request
+        # Keep track of the OTEL span and the restify promise in the
+        # queued Typhoeus request.
+        #
+        # We need to access these to restore the tracing context, or
+        # bubble up exception that happen in the background thread after
+        # queuing, but when Hydra adds the requests to libcurl.
+        attr_accessor :_otel_span, :_restify_writer
+      end
     end
   end
 end

data/lib/restify/context.rb

@@ -51,9 +51,9 @@ module Restify
       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) }
@@ -80,7 +80,7 @@ module Restify
     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/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/processors/base/parsing.rb

@@ -9,11 +9,6 @@ module Restify
       # Parses generic data structures into resources
       #
       module Parsing
-        def self.included(base)
-          base.extend ClassMethods
-          base.indifferent_access = true
-        end
-
         def load
           parse deserialized_body, root: true
         end
@@ -24,12 +19,10 @@ module Restify
               data      = object.each_with_object({}) {|each, obj| parse_data(each, obj) }
               relations = object.each_with_object({}) {|each, obj| parse_rels(each, obj) }
 
-              data = with_indifferent_access(data) if self.class.indifferent_access?
-
               Resource.new context,
-                data: data,
+                data:,
                 response: root ? response : nil,
-                relations: relations
+                relations:
 
             when Array
               object.map {|each| parse(each) }
@@ -58,18 +51,6 @@ module Restify
 
           relations[name] = pair[1].to_s
         end
-
-        def with_indifferent_access(data)
-          Hashie::Mash.new data
-        end
-
-        module ClassMethods
-          def indifferent_access?
-            @indifferent_access
-          end
-
-          attr_writer :indifferent_access
-        end
       end
     end
   end

data/lib/restify/processors/base.rb

@@ -16,7 +16,7 @@ module Restify
         @resource ||= begin
           resource = load
 
-          resource = Resource.new context, response: response, data: resource unless resource.is_a? Restify::Resource
+          resource = Resource.new context, response:, data: resource unless resource.is_a? Restify::Resource
 
           resource._restify_response = response
           merge_relations! resource._restify_relations

data/lib/restify/promise.rb

@@ -25,8 +25,8 @@ module Restify
       self
     end
 
-    def then(&block)
-      Promise.new([self], &block)
+    def then(&)
+      Promise.new([self], &)
     end
 
     def execute(timeout = nil)

data/lib/restify/registry.rb

@@ -7,7 +7,7 @@ module Restify
     end
 
     def store(name, uri, **opts)
-      @registry[name] = Context.new uri, **opts
+      @registry[name] = Context.new(uri, **opts)
     end
 
     def fetch(name)