http_instrumentation 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2df5ce2bdf71e28c9a3c95afa298ef3d1d035d17dbc5b8afb8deced97b1d336c
+  data.tar.gz: debfebac778a078bb34ccaa213389e1785bae0f02f116ba8d4aa2e1584dc26cb
+SHA512:
+  metadata.gz: b268d25d6e6a7e948b68e47d0e08762e3c4708a78feaa17821ebe65ae06d7f675c1ae26a45afb27c983fe5d625f47c4f4cdfa4023ef33b7d71deda6e163d5385
+  data.tar.gz: 4fc09ff4a26388982f0f2b877c7827cd629bfd0f4905f71e6f31a1ab3c5dbd565b39da5cd96b185319daea8fc445b3b4cc58ef0a3744fe08c0a5eebe2d8e5fe3

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+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)
+
+### Added
+- Initial release.

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright 2023 Brian Durand
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,154 @@
+# HTTP Instrumentation
+
+[![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)
+
+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).
+
+### Supported Libraries
+
+* [net/http](https://docs.ruby-lang.org/en/master/Net/HTTP.html) (from the Ruby standard library)
+* [curb](https://github.com/taf2/curb)
+* [ethon](https://github.com/typhoeus/ethon)
+* [excon](https://github.com/excon/excon)
+* [http](https://github.com/httprb/http) (a.k.a. http.rb)
+* [httpclient](https://github.com/nahi/httpclient)
+* [httpx](https://github.com/HoneyryderChuck/httpx)
+* [patron](https://github.com/toland/patron)
+* [typhoeus](https://github.com/typhoeus/typhoeus)
+
+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.
+
+## 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).
+
+The payload on event notifications for all HTTP requests will include:
+
+* `:client` - The client library used to make the request
+* `:count` - The number of HTTP requests that were made
+
+If a single HTTP request was made, then these keys will exist as well:
+
+* `:uri` - The URI for the request
+* `:url` - The URL for the request with any query string stripped off
+* `:http_method` - The HTTP method for the request
+* `:status_code` - The numeric HTTP status code for the response
+
+These additional values will not be present if multiple, concurrent requests were made. Only the typhoeus, ethon, and httpx libraries support making concurrent requests.
+
+```ruby
+ActiveSupport::Notifications.monotonic_subscribe("request.http") do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  client = event.payload[:client]
+  count = event.payload[:count]
+  url = event.payload[:url]
+  uri = event.payload[:uri]
+  http_method = event.payload[:http_method]
+  status_code = event.payload[:status_code]
+
+  puts "HTTP request: client: #{client}, count: #{count}, duration: #{event.duration}ms"
+  if count == 1
+    puts "#{http_method} #{url} - status: #{status_code}, host: #{uri&.host}"
+  end
+end
+
+# Single request
+Net::HTTP.get(URI("https://example.com/info"))
+# => HTTP request: client: net/http, count: 1, duration: 100ms
+# => GET https://example.com/info - status 200, host: example.com
+
+# Multiple, concurrent requests
+HTTPX.get("https://example.com/r1", "https://example.com/r2")
+# => HTTP request: client: httpx, count: 2, duration: 150ms
+```
+
+### 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.
+
+The `:url` element will also have the query string stripped from it so it will just include the scheme, host, and path.
+
+```ruby
+HTTP.get("https://user@password123@example.com/path")
+HTTP.get("https://example.com/path?access_token=secrettoken")
+# event.payload[:url] will be https://example.com/path in both cases
+```
+
+The hostname will also be converted to lowercase in these attributes.
+
+### Silencing Notifications
+
+If you want to suppress notifications, you can do so by surrounding code with an `HTTPInstrumentation.silence` block.
+
+```ruby
+HTTPInstrumentation.silence do
+  HTTP.get("https://example.com/info") # Notification will not be sent
+end
+```
+
+### Custom HTTP Clients
+
+You can instrument additional HTTP calls with the `HTTPInstrumentation.instrument` method. Adding instrumentation to higher level clients will suppress any instrumentation from lower level clients they may be using so you'll only get one event per request.
+
+```ruby
+class MyHttpClient
+  def get(url)
+    HTTPInstrumentation.instrument("my_client") do |payload|
+      response = Net::HTTP.get(URI(url))
+
+      payload[:http_method] = :get
+      payload[:url] = url
+      payload[:status_code] = response.code
+
+      response
+    end
+  end
+end
+
+MyHttpClient.get("https://example.com/")
+# Event => {client: "my_client", http_method => :get, url: "https://example.com/"}
+```
+
+You can also take advantage of the existing instrumentation and just override the client name in the notification event.
+
+```ruby
+class MyHttpClient
+  def get(url)
+    HTTPInstrumentation.client("my_client")
+      Net::HTTP.get(URI(url))
+    end
+  end
+end
+
+MyHttpClient.get("https://example.com/")
+# Event => {client: "my_client", http_method => :get, url: "https://example.com/"}
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "http_instrumentation"
+```
+
+Then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install http_instrumentation
+```
+
+## Contributing
+
+Open a pull request on [GitHub](https://github.com/bdurand/http_instrumentation).
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/http_instrumentation.gemspec

@@ -0,0 +1,37 @@
+Gem::Specification.new do |spec|
+  spec.name = "http_instrumentation"
+  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "ActiveSupoprt instrumentation for a variety of Ruby HTTP client libraries."
+
+  spec.homepage = "https://github.com/bdurand/http_instrumentation"
+  spec.license = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  ignore_files = %w[
+    .
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    config.ru
+    assets/
+    bin/
+    gemfiles/
+    spec/
+  ]
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.5"
+
+  spec.add_dependency "activesupport", ">= 4.2"
+
+  spec.add_development_dependency "bundler"
+end

data/lib/http_instrumentation/instrumentation/curb_hook.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+begin
+  require "curb"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    # This module is responsible for instrumenting the curb gem.
+    module CurbHook
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::Curl::Easy, self) if defined?(::Curl::Easy)
+        end
+
+        def installed?
+          !!(defined?(::Curl::Easy) && ::Curl::Easy.include?(self))
+        end
+      end
+
+      def http(method, *)
+        HTTPInstrumentation.instrument("curb") do |payload|
+          retval = super
+
+          payload[:http_method] = method
+          begin
+            payload[:url] = url
+            payload[:status_code] = response_code
+          rescue
+          end
+
+          retval
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation/ethon_hook.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+begin
+  require "ethon"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    # This module is responsible for instrumenting the ethon gem.
+    module EthonHook
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::Ethon::Easy, Easy) if defined?(::Ethon::Easy)
+          Instrumentation.instrument!(::Ethon::Multi, Multi) if defined?(::Ethon::Multi)
+        end
+
+        def installed?
+          !!(
+            defined?(::Ethon::Easy) && ::Ethon::Easy.include?(Easy) &&
+            defined?(::Ethon::Multi) && ::Ethon::Multi.include?(Multi)
+          )
+        end
+      end
+
+      module Multi
+        def perform(*)
+          HTTPInstrumentation.instrument("ethon") do |payload|
+            begin
+              payload[:count] = easy_handles.size
+            rescue
+            end
+
+            super
+          end
+        end
+      end
+
+      module Easy
+        def http_request(url, action_name, *)
+          @http_method = action_name
+          @http_url = url
+          super
+        end
+
+        def perform(*)
+          HTTPInstrumentation.instrument("ethon") do |payload|
+            retval = super
+
+            payload[:http_method] = @http_method
+            payload[:url] = @http_url
+            begin
+              payload[:status_code] = response_code
+            rescue
+            end
+
+            retval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation/excon_hook.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+begin
+  require "excon"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    # This module is used to instrument the excon gem.
+    module ExconHook
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::Excon::Connection, self) if defined?(::Excon::Connection)
+        end
+
+        def installed?
+          !!(defined?(::Excon::Connection) && ::Excon::Connection.include?(self))
+        end
+      end
+
+      def request(params = {}, *)
+        HTTPInstrumentation.instrument("excon") do |payload|
+          response = super
+
+          begin
+            info = params
+            if respond_to?(:connection)
+              info = info.merge(connection)
+            elsif respond_to?(:data)
+              info = info.merge(data)
+            end
+
+            scheme = info[:scheme]&.downcase
+            default_port = ((scheme == "https") ? 443 : 80)
+            port = info[:port]
+            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[:status_code] = response.status
+          rescue
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation/http_hook.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+begin
+  require "http"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    # This module is responsible for instrumenting the http gem.
+    module HTTPHook
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::HTTP::Client, self) if defined?(::HTTP::Client)
+        end
+
+        def installed?
+          !!(defined?(::HTTP::Client) && ::HTTP::Client.include?(self))
+        end
+      end
+
+      def perform(request, *)
+        HTTPInstrumentation.instrument("http") do |payload|
+          response = super
+
+          begin
+            payload[:http_method] = request.verb
+            payload[:url] = request.uri
+            payload[:status_code] = response.status
+          rescue
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation/httpclient_hook.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+begin
+  require "httpclient"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    module HTTPClientHook
+      # This module is responsible for instrumenting the httpclient gem.
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::HTTPClient, self) if defined?(::HTTPClient)
+        end
+
+        def installed?
+          !!(defined?(::HTTPClient) && ::HTTPClient.include?(self))
+        end
+      end
+
+      def do_get_block(request, *)
+        HTTPInstrumentation.instrument("httpclient") do |payload|
+          response = super
+
+          begin
+            payload[:http_method] = request.header.request_method
+            payload[:url] = request.header.request_uri
+            payload[:status_code] = response.header.status_code
+          rescue
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation/httpx_hook.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+begin
+  require "httpx"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    # This module is responsible for instrumenting the httpx gem.
+    module HTTPXHook
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::HTTPX::Session, self) if defined?(::HTTPX::Session)
+        end
+
+        def installed?
+          !!(defined?(::HTTPX::Session) && ::HTTPX::Session.include?(self))
+        end
+      end
+
+      private
+
+      def send_requests(*requests)
+        HTTPInstrumentation.instrument("httpx") do |payload|
+          responses = super
+
+          if requests.size == 1
+            begin
+              payload[:http_method] = requests.first.verb
+              payload[:url] = requests.first.uri
+              payload[:status_code] = responses.first.status
+            rescue
+            end
+          else
+            payload[:count] = requests.size
+          end
+
+          responses
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation/net_http_hook.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+begin
+  require "net/http"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    # This module is responsible for instrumenting the net/http module in the standard library.
+    module NetHTTPHook
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::Net::HTTP, self) if defined?(::Net::HTTP)
+        end
+
+        def installed?
+          !!(defined?(::Net::HTTP) && ::Net::HTTP.include?(self))
+        end
+      end
+
+      def request(req, *)
+        return super unless started?
+
+        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
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation/patron_hook.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+begin
+  require "patron"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    # This module is responsible for instrumenting the patron gem.
+    module PatronHook
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::Patron::Session, self) if defined?(::Patron::Session)
+        end
+
+        def installed?
+          !!(defined?(::Patron::Session) && ::Patron::Session.include?(self))
+        end
+      end
+
+      private
+
+      def request(action, url, *)
+        HTTPInstrumentation.instrument("patron") do |payload|
+          response = super
+
+          payload[:http_method] = action
+          payload[:url] = url
+          begin
+            payload[:status_code] = response.status
+          rescue
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation/typhoeus_hook.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+begin
+  require "typhoeus"
+rescue LoadError
+end
+
+module HTTPInstrumentation
+  module Instrumentation
+    # This module is responsible for instrumenting the typhoeus gem.
+    module TyphoeusHook
+      class << self
+        def instrument!
+          Instrumentation.instrument!(::Typhoeus::Request, Easy) if defined?(::Typhoeus::Request)
+          Instrumentation.instrument!(::Typhoeus::Hydra, Multi) if defined?(::Typhoeus::Hydra)
+        end
+
+        def installed?
+          !!(
+            defined?(::Typhoeus::Request) && ::Typhoeus::Request.include?(Easy) &&
+            defined?(::Typhoeus::Hydra) && ::Typhoeus::Hydra.include?(Multi)
+          )
+        end
+      end
+
+      module Multi
+        def run(*)
+          HTTPInstrumentation.instrument("typhoeus") do |payload|
+            begin
+              payload[:count] = queued_requests.size
+            rescue
+            end
+
+            super
+          end
+        end
+      end
+
+      module Easy
+        def run(*)
+          HTTPInstrumentation.instrument("typhoeus") do |payload|
+            retval = super
+
+            begin
+              payload[:http_method] = options[:method]
+              payload[:url] = url
+              payload[:status_code] = response&.response_code
+            rescue
+            end
+
+            retval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/http_instrumentation/instrumentation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "instrumentation/curb_hook"
+require_relative "instrumentation/ethon_hook"
+require_relative "instrumentation/excon_hook"
+require_relative "instrumentation/httpclient_hook"
+require_relative "instrumentation/http_hook"
+require_relative "instrumentation/httpx_hook"
+require_relative "instrumentation/net_http_hook"
+require_relative "instrumentation/patron_hook"
+require_relative "instrumentation/typhoeus_hook"
+
+module HTTPInstrumentation
+  module Instrumentation
+    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)
+      end
+    end
+  end
+end

data/lib/http_instrumentation.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+require_relative "http_instrumentation/instrumentation"
+
+module HTTPInstrumentation
+  IMPLEMENTATIONS = [
+    :curb,
+    :ethon,
+    :excon,
+    :http,
+    :httpclient,
+    :httpx,
+    :net_http,
+    :net_http2,
+    :patron,
+    :typhoeus
+  ].freeze
+
+  EVENT = "request.http"
+
+  class << self
+    # Add instrumentation into HTTP client libraries. By default all supported
+    # libraries are instrumented. You can pass the only or except options
+    # to limit the instrumentation to a subset of libraries.
+    #
+    # @param only [Array<Symbol>] List of libraries to instrument.
+    # @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
+
+      Instrumentation::CurbHook.instrument! if list.include?(:curb)
+      Instrumentation::EthonHook.instrument! if list.include?(:ethon)
+      Instrumentation::ExconHook.instrument! if list.include?(:excon)
+      Instrumentation::HTTPHook.instrument! if list.include?(:http)
+      Instrumentation::HTTPClientHook.instrument! if list.include?(:httpclient)
+      Instrumentation::HTTPXHook.instrument! if list.include?(:httpx)
+      Instrumentation::NetHTTPHook.instrument! if list.include?(:net_http)
+      Instrumentation::PatronHook.instrument! if list.include?(:patron)
+      Instrumentation::TyphoeusHook.instrument! if list.include?(:typhoeus)
+    end
+
+    # Silence instrumentation for the duration of the block.
+    #
+    # @return [Object] the return value of the block
+    def silence(&block)
+      save_val = Thread.current[:http_instrumentation_silence]
+      begin
+        Thread.current[:http_instrumentation_silence] = true
+        yield
+      ensure
+        Thread.current[:http_instrumentation_silence] = save_val
+      end
+    end
+
+    # If a block is given, then set the HTTP client name for the duration of the
+    # 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
+    def client(name = nil)
+      save_val = Thread.current[:http_instrumentation_client]
+      if block_given?
+        begin
+          Thread.current[:http_instrumentation_client] = name
+          yield
+        ensure
+          Thread.current[:http_instrumentation_client] = save_val
+        end
+      end
+      save_val
+    end
+
+    # Returns true if instrumentation is currently silenced.
+    #
+    # @return [Boolean]
+    def silenced?
+      !!Thread.current[:http_instrumentation_silence]
+    end
+
+    # Instrument the given block with the given client name. An ActiveSupport event will be
+    # fired with the following payload:
+    #
+    # * `:client` - The name of the client as a string.
+    # * `:http_method` - The HTTP method as a lowercase symbol.
+    # * `:url` - The URL as a string.
+    # * `:uri` - The URL as a URI object.
+    # * `:status_code` - The HTTP status code as an integer.
+    # * `:count` - The number of requests made as an integer.
+    #
+    # @param client [String, Symbol] The name of the client.
+    # @return [Object] the return value of the block
+    def instrument(client, &block)
+      payload = {client: (self.client || client).to_s}
+
+      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
+
+        payload[:status_code] = payload[:status_code]&.to_i if payload.include?(:status_code)
+
+        payload[:count] = (payload.include?(:count) ? payload[:count].to_i : 1)
+
+        retval
+      end
+    end
+
+    private
+
+    # Turn the given value into a lowercase symbol.
+    def normalize_http_method(method)
+      return nil if method.nil?
+      method.to_s.downcase.to_sym
+    end
+
+    # Remove any sensitive information from the given URL. Also normalizes
+    # the host and protocol by downcasing them.
+    #
+    # @param url [URI] the sanitized URL
+    def sanitized_uri(url)
+      return nil if url.nil?
+
+      begin
+        uri = URI(url.to_s)
+      rescue URI::Error
+        return nil
+      end
+
+      uri.password = nil
+      uri.user = nil
+      uri.host = uri.host&.downcase
+
+      if uri.respond_to?(:query=) && uri.query
+        params = nil
+        begin
+          params = URI.decode_www_form(uri.query)
+        rescue
+          params = {}
+        end
+        params.reject! { |name, value| name == "access_token" }
+        uri.query = (params.empty? ? nil : URI.encode_www_form(params))
+      end
+
+      uri
+    end
+
+    def uri_without_query_string(uri)
+      URI("#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}").to_s
+    end
+  end
+end
+
+HTTPInstrumentation.initialize!

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: http_instrumentation
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Durand
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE.txt
+- README.md
+- VERSION
+- http_instrumentation.gemspec
+- lib/http_instrumentation.rb
+- lib/http_instrumentation/instrumentation.rb
+- lib/http_instrumentation/instrumentation/curb_hook.rb
+- lib/http_instrumentation/instrumentation/ethon_hook.rb
+- lib/http_instrumentation/instrumentation/excon_hook.rb
+- lib/http_instrumentation/instrumentation/http_hook.rb
+- lib/http_instrumentation/instrumentation/httpclient_hook.rb
+- lib/http_instrumentation/instrumentation/httpx_hook.rb
+- lib/http_instrumentation/instrumentation/net_http_hook.rb
+- lib/http_instrumentation/instrumentation/patron_hook.rb
+- lib/http_instrumentation/instrumentation/typhoeus_hook.rb
+homepage: https://github.com/bdurand/http_instrumentation
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.12
+signing_key:
+specification_version: 4
+summary: ActiveSupoprt instrumentation for a variety of Ruby HTTP client libraries.
+test_files: []