http_instrumentation 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2df5ce2bdf71e28c9a3c95afa298ef3d1d035d17dbc5b8afb8deced97b1d336c
-  data.tar.gz: debfebac778a078bb34ccaa213389e1785bae0f02f116ba8d4aa2e1584dc26cb
+  metadata.gz: 2deee15a4609f8d50a706613af0805d53bc54beaf3e17f65b68f17c17453fed9
+  data.tar.gz: a3a76bc88fe4a5b799b59a807ac665dcd4b6f52f280236f7b8b804425a01846f
 SHA512:
-  metadata.gz: b268d25d6e6a7e948b68e47d0e08762e3c4708a78feaa17821ebe65ae06d7f675c1ae26a45afb27c983fe5d625f47c4f4cdfa4023ef33b7d71deda6e163d5385
-  data.tar.gz: 4fc09ff4a26388982f0f2b877c7827cd629bfd0f4905f71e6f31a1ab3c5dbd565b39da5cd96b185319daea8fc445b3b4cc58ef0a3744fe08c0a5eebe2d8e5fe3
+  metadata.gz: 932361a2de24b64de68929b61379e1d8f01acce64f3f03070070ccfb9da8a369329c7703f84f774e236c69a2343dde4c5a6add5fd21add2db9025cdde3515a7b
+  data.tar.gz: fa77a297e489a26894c6f49961a5f057bfb239385a93d96b0252892db411922e9e2c75d0abb9de663fe059d883d9e07f06a043ae27b7704a4e868c97a49d4eb8

data/CHANGELOG.md

@@ -4,7 +4,34 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## 1.0.0 (unreleased)
+## 1.0.2
+
+### Fixed
+- Requiring the gem now loads the ActiveSupport framework itself instead of just `active_support/notifications`, which is not self-sufficient on ActiveSupport 7+ and raised `NameError: uninitialized constant ActiveSupport::IsolatedExecutionState` on the first request if the host application had not already loaded ActiveSupport.
+- The httpclient and excon instrumentation now forward blocks passed to the instrumented methods, so streaming response blocks are no longer silently ignored when the aliasing strategy is used.
+- The excon instrumentation now encodes query parameters passed as a hash when building the URL for the event payload, so `access_token` parameters are properly stripped from the `:uri` payload value instead of leaking through in unparseable form.
+- The aliased flag on instrumentation modules is now set before the instrumented method is swapped in, so a request on another thread can no longer hit a window during installation where it would raise `NoMethodError`.
+- Removed the nonexistent `:net_http2` entry from `HTTPInstrumentation::IMPLEMENTATIONS`; no hook for it was ever implemented.
+- `HTTPInstrumentation.initialize!` now accepts a single symbol for the `only` option instead of raising `NoMethodError`.
+- The `except` option to `HTTPInstrumentation.initialize!` now excludes the listed libraries instead of instrumenting only those libraries.
+- Requests made with relative URLs (e.g. a patron session with a `base_url`) no longer raise `URI::InvalidURIError` from the instrumentation after the request completes.
+- Installing the instrumentation is now protected by a mutex so concurrent calls to `initialize!` cannot install the aliased methods twice, which would have caused infinite recursion on subsequent requests.
+- The excon instrumentation now reports per-request values (path, query, etc.) instead of letting the connection's defaults override them in the event payload.
+- The event payload now always includes the `:count` key even when the request raises an error.
+- The net/http instrumentation no longer lets an error raised while building the event payload escape to the caller, matching the behavior of the other hooks.
+- The ethon instrumentation clears the request info captured from `http_request` after each `perform`, so reusing an easy handle without going through `http_request` no longer reports the previous request's method and URL. The URL set directly on the handle is now also reported as a fallback.
+- The `:url` payload value no longer includes an explicit port for URLs using the default port for their scheme.
+
+### Changed
+- The minimum required Ruby version has been updated to 2.6.
+
+## 1.0.1
+
+### Fixed
+- Added detection for other gems that may be instrumenting these same libraries and ensuring that the method of injecting the instrumentation call is compatible. This fixes issues caused by the fundamental incompatibility in Ruby between `alias_method` and `prepend` on the same method. Aliasing is now the default method for injection since this is the most compatible. However if another library has already prepended behavior on a method, then `prepend` will be used instead.
+- `HTTPInstrumentation.client` properly returns the block return value if it was called with a block.
+
+## 1.0.0
 
 ### Added
 - Initial release.

data/README.md

@@ -2,6 +2,7 @@
 
 [![Continuous Integration](https://github.com/bdurand/http_instrumentation/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/http_instrumentation/actions/workflows/continuous_integration.yml)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Version](https://badge.fury.io/rb/http_instrumentation.svg)](https://badge.fury.io/rb/http_instrumentation)
 
 This gem adds instrumentation to a variety of the most commonly used Ruby HTTP client libraries via ActiveSupport notifications. The goal is to add a common instrumentation interface across all the HTTP client libraries used by an application (including ones installed as dependencies of other gems).
 
@@ -19,6 +20,8 @@ This gem adds instrumentation to a variety of the most commonly used Ruby HTTP c
 
 Note that several other popular HTTP client libraries like [Faraday](https://github.com/lostisland/faraday), [HTTParty](https://github.com/jnunemaker/httparty), and [RestClient](https://github.com/rest-client/rest-client) are built on top of these low level libraries.
 
+A few code paths are not instrumented: curb requests that don't go through `Curl::Easy#http` (e.g. the native `http_get` and `http_post` helpers) and httpclient streaming responses.
+
 ## Usage
 
 To capture information about HTTP requests, simply subscribe to the `request.http` events with [ActiveSupport notifications](https://api.rubyonrails.org/classes/ActiveSupport/Notifications.html) (note that you should really use `monotonic_subscribe` instead of `subscribe` to avoid issues with clock adjustments).
@@ -63,6 +66,17 @@ HTTPX.get("https://example.com/r1", "https://example.com/r2")
 # => HTTP request: client: httpx, count: 2, duration: 150ms
 ```
 
+### Instrumenting Libraries Loaded Later
+
+All supported libraries that have already been loaded are automatically instrumented when this gem is required. Instrumentation cannot be removed once it has been installed.
+
+If an HTTP client library is loaded after this gem, you can call `HTTPInstrumentation.initialize!` again to instrument it. The `only` and `except` options can be used to limit which libraries are instrumented.
+
+```ruby
+require "httpx"
+HTTPInstrumentation.initialize!(only: [:httpx])
+```
+
 ### Security
 
 The `:uri` element in the event payload will be sanitized to remove any user/password elements encoded in the URL as well as any `access_token` query parameters.
@@ -115,7 +129,7 @@ You can also take advantage of the existing instrumentation and just override th
 ```ruby
 class MyHttpClient
   def get(url)
-    HTTPInstrumentation.client("my_client")
+    HTTPInstrumentation.client("my_client") do
       Net::HTTP.get(URI(url))
     end
   end

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.2

data/http_instrumentation.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.5"
+  spec.required_ruby_version = ">= 2.6"
 
   spec.add_dependency "activesupport", ">= 4.2"
 

data/lib/http_instrumentation/instrumentation/curb_hook.rb

@@ -11,17 +11,23 @@ module HTTPInstrumentation
     module CurbHook
       class << self
         def instrument!
-          Instrumentation.instrument!(::Curl::Easy, self) if defined?(::Curl::Easy)
+          Instrumentation.instrument!(::Curl::Easy, self, :http) if defined?(::Curl::Easy)
         end
 
         def installed?
           !!(defined?(::Curl::Easy) && ::Curl::Easy.include?(self))
         end
+
+        attr_accessor :aliased
       end
 
-      def http(method, *)
+      def http(method, *args)
         HTTPInstrumentation.instrument("curb") do |payload|
-          retval = super
+          retval = if HTTPInstrumentation::Instrumentation::CurbHook.aliased
+            http_without_http_instrumentation(method, *args)
+          else
+            super
+          end
 
           payload[:http_method] = method
           begin

data/lib/http_instrumentation/instrumentation/ethon_hook.rb

@@ -11,8 +11,8 @@ module HTTPInstrumentation
     module EthonHook
       class << self
         def instrument!
-          Instrumentation.instrument!(::Ethon::Easy, Easy) if defined?(::Ethon::Easy)
-          Instrumentation.instrument!(::Ethon::Multi, Multi) if defined?(::Ethon::Multi)
+          Instrumentation.instrument!(::Ethon::Easy, Easy, [:http_request, :perform]) if defined?(::Ethon::Easy)
+          Instrumentation.instrument!(::Ethon::Multi, Multi, :perform) if defined?(::Ethon::Multi)
         end
 
         def installed?
@@ -24,31 +24,60 @@ module HTTPInstrumentation
       end
 
       module Multi
-        def perform(*)
+        class << self
+          attr_accessor :aliased
+        end
+
+        def perform(*args)
           HTTPInstrumentation.instrument("ethon") do |payload|
             begin
               payload[:count] = easy_handles.size
             rescue
             end
 
-            super
+            if HTTPInstrumentation::Instrumentation::EthonHook::Multi.aliased
+              perform_without_http_instrumentation(*args)
+            else
+              super
+            end
           end
         end
       end
 
       module Easy
-        def http_request(url, action_name, *)
-          @http_method = action_name
-          @http_url = url
-          super
+        class << self
+          attr_accessor :aliased
         end
 
-        def perform(*)
+        def http_request(url, action_name, *args)
+          @http_instrumentation_method = action_name
+          @http_instrumentation_url = url
+          if HTTPInstrumentation::Instrumentation::EthonHook::Easy.aliased
+            http_request_without_http_instrumentation(url, action_name, *args)
+          else
+            super
+          end
+        end
+
+        def perform(*args)
           HTTPInstrumentation.instrument("ethon") do |payload|
-            retval = super
+            payload[:http_method] = @http_instrumentation_method
+            begin
+              payload[:url] = (@http_instrumentation_url || url)
+            rescue
+              payload[:url] = @http_instrumentation_url
+            end
+            # Clear the request info so it isn't reported again if the handle
+            # is reused without going through http_request.
+            @http_instrumentation_method = nil
+            @http_instrumentation_url = nil
+
+            retval = if HTTPInstrumentation::Instrumentation::EthonHook::Easy.aliased
+              perform_without_http_instrumentation(*args)
+            else
+              super
+            end
 
-            payload[:http_method] = @http_method
-            payload[:url] = @http_url
             begin
               payload[:status_code] = response_code
             rescue

data/lib/http_instrumentation/instrumentation/excon_hook.rb

@@ -11,31 +11,41 @@ module HTTPInstrumentation
     module ExconHook
       class << self
         def instrument!
-          Instrumentation.instrument!(::Excon::Connection, self) if defined?(::Excon::Connection)
+          Instrumentation.instrument!(::Excon::Connection, self, :request) if defined?(::Excon::Connection)
         end
 
         def installed?
           !!(defined?(::Excon::Connection) && ::Excon::Connection.include?(self))
         end
+
+        attr_accessor :aliased
       end
 
-      def request(params = {}, *)
+      def request(params = {}, &block)
         HTTPInstrumentation.instrument("excon") do |payload|
-          response = super
+          response = if HTTPInstrumentation::Instrumentation::ExconHook.aliased
+            request_without_http_instrumentation(params, &block)
+          else
+            super
+          end
 
           begin
             info = params
+            # Merge connection defaults under the per-request params so the
+            # request values win.
             if respond_to?(:connection)
-              info = info.merge(connection)
+              info = connection.merge(params)
             elsif respond_to?(:data)
-              info = info.merge(data)
+              info = data.merge(params)
             end
 
             scheme = info[:scheme]&.downcase
             default_port = ((scheme == "https") ? 443 : 80)
             port = info[:port]
+            query = info[:query]
+            query = URI.encode_www_form(query) if query.is_a?(Hash)
             payload[:http_method] = (info[:http_method] || info[:method])
-            payload[:url] = "#{scheme}://#{info[:host]}#{":#{port}" unless port == default_port}#{info[:path]}#{"?#{info[:query]}" unless info[:query].to_s.empty?}"
+            payload[:url] = "#{scheme}://#{info[:host]}#{":#{port}" unless port == default_port}#{info[:path]}#{"?#{query}" unless query.to_s.empty?}"
             payload[:status_code] = response.status
           rescue
           end

data/lib/http_instrumentation/instrumentation/http_hook.rb

@@ -11,17 +11,23 @@ module HTTPInstrumentation
     module HTTPHook
       class << self
         def instrument!
-          Instrumentation.instrument!(::HTTP::Client, self) if defined?(::HTTP::Client)
+          Instrumentation.instrument!(::HTTP::Client, self, :perform) if defined?(::HTTP::Client)
         end
 
         def installed?
           !!(defined?(::HTTP::Client) && ::HTTP::Client.include?(self))
         end
+
+        attr_accessor :aliased
       end
 
-      def perform(request, *)
+      def perform(request, *args)
         HTTPInstrumentation.instrument("http") do |payload|
-          response = super
+          response = if HTTPInstrumentation::Instrumentation::HTTPHook.aliased
+            perform_without_http_instrumentation(request, *args)
+          else
+            super
+          end
 
           begin
             payload[:http_method] = request.verb

data/lib/http_instrumentation/instrumentation/httpclient_hook.rb

@@ -11,17 +11,23 @@ module HTTPInstrumentation
       # This module is responsible for instrumenting the httpclient gem.
       class << self
         def instrument!
-          Instrumentation.instrument!(::HTTPClient, self) if defined?(::HTTPClient)
+          Instrumentation.instrument!(::HTTPClient, self, :do_get_block) if defined?(::HTTPClient)
         end
 
         def installed?
           !!(defined?(::HTTPClient) && ::HTTPClient.include?(self))
         end
+
+        attr_accessor :aliased
       end
 
-      def do_get_block(request, *)
+      def do_get_block(request, *args, &block)
         HTTPInstrumentation.instrument("httpclient") do |payload|
-          response = super
+          response = if HTTPInstrumentation::Instrumentation::HTTPClientHook.aliased
+            do_get_block_without_http_instrumentation(request, *args, &block)
+          else
+            super
+          end
 
           begin
             payload[:http_method] = request.header.request_method

data/lib/http_instrumentation/instrumentation/httpx_hook.rb

@@ -11,19 +11,25 @@ module HTTPInstrumentation
     module HTTPXHook
       class << self
         def instrument!
-          Instrumentation.instrument!(::HTTPX::Session, self) if defined?(::HTTPX::Session)
+          Instrumentation.instrument!(::HTTPX::Session, self, :send_requests) if defined?(::HTTPX::Session)
         end
 
         def installed?
           !!(defined?(::HTTPX::Session) && ::HTTPX::Session.include?(self))
         end
+
+        attr_accessor :aliased
       end
 
       private
 
       def send_requests(*requests)
         HTTPInstrumentation.instrument("httpx") do |payload|
-          responses = super
+          responses = if HTTPInstrumentation::Instrumentation::HTTPXHook.aliased
+            send_requests_without_http_instrumentation(*requests)
+          else
+            super
+          end
 
           if requests.size == 1
             begin

data/lib/http_instrumentation/instrumentation/net_http_hook.rb

@@ -11,26 +11,43 @@ module HTTPInstrumentation
     module NetHTTPHook
       class << self
         def instrument!
-          Instrumentation.instrument!(::Net::HTTP, self) if defined?(::Net::HTTP)
+          Instrumentation.instrument!(::Net::HTTP, self, :request) if defined?(::Net::HTTP)
         end
 
         def installed?
           !!(defined?(::Net::HTTP) && ::Net::HTTP.include?(self))
         end
+
+        attr_accessor :aliased
       end
 
-      def request(req, *)
-        return super unless started?
+      def request(req, *args, &block)
+        unless started?
+          if HTTPInstrumentation::Instrumentation::NetHTTPHook.aliased
+            return request_without_http_instrumentation(req, *args, &block)
+          else
+            return super
+          end
+        end
 
         HTTPInstrumentation.instrument("net/http") do |payload|
-          response = super
-
-          default_port = (use_ssl? ? 443 : 80)
-          scheme = (use_ssl? ? "https" : "http")
-          url = "#{scheme}://#{address}#{":#{port}" unless port == default_port}#{req.path}"
-          payload[:http_method] = req.method
-          payload[:url] = url
-          payload[:status_code] = response.code
+          response = if HTTPInstrumentation::Instrumentation::NetHTTPHook.aliased
+            request_without_http_instrumentation(req, *args, &block)
+          else
+            super
+          end
+
+          begin
+            default_port = (use_ssl? ? 443 : 80)
+            scheme = (use_ssl? ? "https" : "http")
+            url = "#{scheme}://#{address}#{":#{port}" unless port == default_port}#{req.path}"
+            payload[:http_method] = req.method
+            payload[:url] = url
+            payload[:status_code] = response.code
+          rescue
+            # Instrumentation must never break the request; if the payload can't
+            # be built, return the response without the extra fields.
+          end
 
           response
         end

data/lib/http_instrumentation/instrumentation/patron_hook.rb

@@ -11,19 +11,25 @@ module HTTPInstrumentation
     module PatronHook
       class << self
         def instrument!
-          Instrumentation.instrument!(::Patron::Session, self) if defined?(::Patron::Session)
+          Instrumentation.instrument!(::Patron::Session, self, :request) if defined?(::Patron::Session)
         end
 
         def installed?
           !!(defined?(::Patron::Session) && ::Patron::Session.include?(self))
         end
+
+        attr_accessor :aliased
       end
 
       private
 
-      def request(action, url, *)
+      def request(action, url, *args)
         HTTPInstrumentation.instrument("patron") do |payload|
-          response = super
+          response = if HTTPInstrumentation::Instrumentation::PatronHook.aliased
+            request_without_http_instrumentation(action, url, *args)
+          else
+            super
+          end
 
           payload[:http_method] = action
           payload[:url] = url

data/lib/http_instrumentation/instrumentation/typhoeus_hook.rb

@@ -11,8 +11,8 @@ module HTTPInstrumentation
     module TyphoeusHook
       class << self
         def instrument!
-          Instrumentation.instrument!(::Typhoeus::Request, Easy) if defined?(::Typhoeus::Request)
-          Instrumentation.instrument!(::Typhoeus::Hydra, Multi) if defined?(::Typhoeus::Hydra)
+          Instrumentation.instrument!(::Typhoeus::Request, Easy, :run) if defined?(::Typhoeus::Request)
+          Instrumentation.instrument!(::Typhoeus::Hydra, Multi, :run) if defined?(::Typhoeus::Hydra)
         end
 
         def installed?
@@ -24,22 +24,38 @@ module HTTPInstrumentation
       end
 
       module Multi
-        def run(*)
+        class << self
+          attr_accessor :aliased
+        end
+
+        def run(*args)
           HTTPInstrumentation.instrument("typhoeus") do |payload|
             begin
               payload[:count] = queued_requests.size
             rescue
             end
 
-            super
+            if HTTPInstrumentation::Instrumentation::TyphoeusHook::Multi.aliased
+              run_without_http_instrumentation(*args)
+            else
+              super
+            end
           end
         end
       end
 
       module Easy
-        def run(*)
+        class << self
+          attr_accessor :aliased
+        end
+
+        def run(*args)
           HTTPInstrumentation.instrument("typhoeus") do |payload|
-            retval = super
+            retval = if HTTPInstrumentation::Instrumentation::TyphoeusHook::Easy.aliased
+              run_without_http_instrumentation(*args)
+            else
+              super
+            end
 
             begin
               payload[:http_method] = options[:method]

data/lib/http_instrumentation/instrumentation.rb

@@ -12,10 +12,81 @@ require_relative "instrumentation/typhoeus_hook"
 
 module HTTPInstrumentation
   module Instrumentation
+    # Lock to prevent concurrent calls from installing the same hooks twice;
+    # double aliasing would point the _without_http_instrumentation method at
+    # the instrumented method itself, causing infinite recursion.
+    INSTRUMENT_LOCK = Mutex.new
+    private_constant :INSTRUMENT_LOCK
+
     class << self
-      # Helper method to prepend an instrumentation module to a class.
-      def instrument!(klass, instrumentation_module)
-        klass.prepend(instrumentation_module) unless klass.include?(instrumentation_module)
+      # Helper method to add an instrumentation module to methods on a class. The
+      # methods must be defined in the instrumentation module.
+      #
+      # If the methods have already been prepended on the class, then module will
+      # be prepended to the class. Otherwise, the methods will be aliased and the
+      # module will be included in the class. This is because prepending and aliasing
+      # methods are not compatible with each other and other instrumentation libraries
+      # may have already prepended the methods. Aliasing is the default strategy because
+      # prepending after aliasing will work, but aliasing after prepending will not.
+      def instrument!(klass, instrumentation_module, methods)
+        INSTRUMENT_LOCK.synchronize do
+          return if klass.include?(instrumentation_module)
+
+          methods = Array(methods).collect(&:to_sym)
+
+          if HTTPInstrumentation.force_prepend? || methods_defined_in_module?(klass, methods)
+            klass.prepend(instrumentation_module)
+            instrumentation_module.aliased = false
+          else
+            methods.each do |method|
+              instrumentation_module.alias_method("#{method}_with_http_instrumentation", method)
+            end
+
+            klass.include(instrumentation_module)
+
+            swap_methods = methods.reject { |method| defines_method?(klass, "#{method}_without_http_instrumentation") }
+
+            swap_methods.each do |method|
+              klass.alias_method("#{method}_without_http_instrumentation", method)
+            end
+
+            # The aliased flag must be set before the instrumented methods are
+            # swapped in; a call landing in between would take the super branch
+            # and raise NoMethodError since the module was included, not prepended.
+            instrumentation_module.aliased = true
+
+            swap_methods.each do |method|
+              klass.alias_method(method, "#{method}_with_http_instrumentation")
+            end
+          end
+        end
+      end
+
+      private
+
+      # Returns true if any of the methods are defined in a module in the class's
+      # ancestry rather than directly on the class itself. This covers both modules
+      # prepended in front of the class and modules included behind it. In either
+      # case the aliasing strategy cannot be used: including the instrumentation
+      # module would insert it ahead of the module that defines the method, so
+      # aliasing the method afterward would capture the instrumented method itself
+      # and cause infinite recursion.
+      def methods_defined_in_module?(klass, methods)
+        defined_in_module = false
+
+        klass.ancestors.each do |mod|
+          next unless mod.is_a?(Module) && !mod.is_a?(Class)
+
+          module_methods = mod.instance_methods(false) + mod.private_instance_methods(false)
+          defined_in_module = (module_methods & methods).any?
+          break if defined_in_module
+        end
+
+        defined_in_module
+      end
+
+      def defines_method?(klass, method)
+        klass.method_defined?(method) || klass.private_method_defined?(method)
       end
     end
   end

data/lib/http_instrumentation.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support"
 require "active_support/notifications"
 
 require_relative "http_instrumentation/instrumentation"
@@ -13,7 +14,6 @@ module HTTPInstrumentation
     :httpclient,
     :httpx,
     :net_http,
-    :net_http2,
     :patron,
     :typhoeus
   ].freeze
@@ -29,8 +29,8 @@ module HTTPInstrumentation
     # @param except [Array<Symbol>] List of libraries to not instrument.
     # @return [void]
     def initialize!(only: nil, except: nil)
-      list = (only || IMPLEMENTATIONS)
-      list &= Array(except) if except
+      list = Array(only || IMPLEMENTATIONS)
+      list -= Array(except) if except
 
       Instrumentation::CurbHook.instrument! if list.include?(:curb)
       Instrumentation::EthonHook.instrument! if list.include?(:ethon)
@@ -45,6 +45,9 @@ module HTTPInstrumentation
 
     # Silence instrumentation for the duration of the block.
     #
+    # Note that silencing is stored in fiber-local storage, so it does not
+    # propagate into other threads or fibers spawned within the block.
+    #
     # @return [Object] the return value of the block
     def silence(&block)
       save_val = Thread.current[:http_instrumentation_silence]
@@ -60,18 +63,20 @@ module HTTPInstrumentation
     # block. If no block is given, then return the current HTTP client name.
     #
     # @param name [String, Symbol, nil] The name of the client to set
-    # @return [String, Symbol, nil] The current name of the client
+    # @return [String, Symbol, nil] If a block is given, then the return value of the block. Otherwise
+    #   the current client name.
     def client(name = nil)
       save_val = Thread.current[:http_instrumentation_client]
       if block_given?
         begin
-          Thread.current[:http_instrumentation_client] = name
+          Thread.current[:http_instrumentation_client] = name&.to_s
           yield
         ensure
           Thread.current[:http_instrumentation_client] = save_val
         end
+      else
+        save_val
       end
-      save_val
     end
 
     # Returns true if instrumentation is currently silenced.
@@ -99,29 +104,42 @@ module HTTPInstrumentation
       return yield(payload) if silenced?
 
       ActiveSupport::Notifications.instrument(EVENT, payload) do
-        retval = silence { yield(payload) }
-
-        payload[:http_method] = normalize_http_method(payload[:http_method]) if payload.include?(:http_method)
-
-        if payload.include?(:url)
-          uri = sanitized_uri(payload[:url])
-          if uri
-            payload[:url] = uri_without_query_string(uri)
-            payload[:uri] = uri
-          else
-            payload[:url] = payload[:url]&.to_s
-          end
-        end
+        instrument_request(payload, &block)
+      end
+    end
 
-        payload[:status_code] = payload[:status_code]&.to_i if payload.include?(:status_code)
+    # Returns true if instrumentation should always use module prepend rather than method aliasing.
+    # The default is to use method aliasing since that is more compatible with other libraries.
+    # Prepending can be forced by setting the HTTP_INSTRUMENTATION_FORCE_PREPEND environment variable
+    # to "true".
+    def force_prepend?
+      ENV.fetch("HTTP_INSTRUMENTATION_FORCE_PREPEND", nil) == "true"
+    end
 
-        payload[:count] = (payload.include?(:count) ? payload[:count].to_i : 1)
+    private
 
-        retval
+    # Yield the block with instrumentation silenced and then normalize the
+    # payload. The payload is normalized even if the block raises an error so
+    # that events for failed requests still include the normalized keys.
+    def instrument_request(payload)
+      silence { yield(payload) }
+    ensure
+      payload[:http_method] = normalize_http_method(payload[:http_method]) if payload.include?(:http_method)
+
+      if payload.include?(:url)
+        uri = sanitized_uri(payload[:url])
+        if uri
+          payload[:url] = uri_without_query_string(uri)
+          payload[:uri] = uri
+        else
+          payload[:url] = payload[:url]&.to_s
+        end
       end
-    end
 
-    private
+      payload[:status_code] = payload[:status_code]&.to_i if payload.include?(:status_code)
+
+      payload[:count] = (payload.include?(:count) ? payload[:count].to_i : 1)
+    end
 
     # Turn the given value into a lowercase symbol.
     def normalize_http_method(method)
@@ -161,7 +179,10 @@ module HTTPInstrumentation
     end
 
     def uri_without_query_string(uri)
-      URI("#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}").to_s
+      stripped = uri.dup
+      stripped.query = nil if stripped.respond_to?(:query=)
+      stripped.fragment = nil if stripped.respond_to?(:fragment=)
+      stripped.to_s
     end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: http_instrumentation
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Brian Durand
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,7 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email:
 - bbdurand@gmail.com
 executables: []
@@ -65,7 +63,6 @@ homepage: https://github.com/bdurand/http_instrumentation
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -73,15 +70,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: ActiveSupoprt instrumentation for a variety of Ruby HTTP client libraries.
 test_files: []