opentelemetry-instrumentation-httpx 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f48b37a6804e254fb9d9b7a6e039410d332be2652460c17574be592ac501283c
-  data.tar.gz: df74d2c9904a866aec5b33947ad9acef4efb147630cd28f7ad7716e0a41ad115
+  metadata.gz: 6c8a1ef0156cbdb24361ce0b786c842a284a5ba882cfa3c9acdd5d1b74774dd2
+  data.tar.gz: 06cecad615cba89782a5eda29c1e7d5de1a7af8db5b172b3e9756349d199290e
 SHA512:
-  metadata.gz: 81c4c857388e3d9784d9016d7d6726ce863c8672aeaf8d3f3b79da244c988fd5e0fe876fadca68743f4d8a3239747f8f7850475b88bd8360ec1dfa655aea002f
-  data.tar.gz: 74de494374914328be9861f8f32191609c0931f0e295afb41dc4fb653716d4bf419fd5fa140a0ca598f0a276d173de4598528ec44f2896da32fdeb0e76c8cebc
+  metadata.gz: 23b8e7faa82ddfe1f9d7a86a7dd8ec14a7ecb0f651c9a2c6d6ec7c08ea97cdbc1ab74d108ccbc54711ae2bad9c539e8c4e38be05bd1089817860aa7715419475
+  data.tar.gz: 0c903889f51a88a7f876712700f7f089e16280d9a459f46c2e86c5f3cd9db856cef079473fef5760e92d805746c288f2f633510380b477cd187988925b3c0078

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Release History: opentelemetry-instrumentation-httpx
 
+### v0.3.0 / 2025-08-12
+
+* ADDED: HTTPX `OTEL_SEMCONV_STABILITY_OPT_IN` environment variable [#1589](https://github.com/open-telemetry/opentelemetry-ruby-contrib/pull/1589)
+
+### v0.2.1 / 2025-04-29
+
+* FIXED: Httpx instrumentation trace context propagation
+
 ### v0.2.0 / 2025-01-16
 
 * BREAKING CHANGE: Set minimum supported version to Ruby 3.1

data/README.md

@@ -48,3 +48,19 @@ The `opentelemetry-instrumentation-httpx` gem is distributed under the Apache 2.
 [slack-channel]: https://cloud-native.slack.com/archives/C01NWKKMKMY
 [discussions-url]: https://github.com/open-telemetry/opentelemetry-ruby/discussions
 [httpx-home]: https://github.com/HoneyryderChuck/httpx
+
+## HTTP semantic convention stability
+
+In the OpenTelemetry ecosystem, HTTP semantic conventions have now reached a stable state. However, the initial HTTPX instrumentation was introduced before this stability was achieved, which resulted in HTTP attributes being based on an older version of the semantic conventions.
+
+To facilitate the migration to stable semantic conventions, you can use the `OTEL_SEMCONV_STABILITY_OPT_IN` environment variable. This variable allows you to opt-in to the new stable conventions, ensuring compatibility and future-proofing your instrumentation.
+
+When setting the value for `OTEL_SEMCONV_STABILITY_OPT_IN`, you can specify which conventions you wish to adopt:
+
+- `http` - Emits the stable HTTP and networking conventions and ceases emitting the old conventions previously emitted by the instrumentation.
+- `http/dup` - Emits both the old and stable HTTP and networking conventions, enabling a phased rollout of the stable semantic conventions.
+- Default behavior (in the absence of either value) is to continue emitting the old HTTP and networking conventions the instrumentation previously emitted.
+
+During the transition from old to stable conventions, HTTPX instrumentation code comes in three patch versions: `dup`, `old`, and `stable`. These versions are identical except for the attributes they send. Any changes to HTTPX instrumentation should consider all three patches.
+
+For additional information on migration, please refer to our [documentation](https://opentelemetry.io/docs/specs/semconv/non-normative/http-migration/).

data/lib/opentelemetry/instrumentation/httpx/dup/plugin.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module HTTPX
+      module Dup
+        module Plugin
+          # Instruments around HTTPX's request/response lifecycle in order to generate
+          # an OTEL trace.
+          module RequestTracer
+            module_function
+
+            # initializes tracing on the +request+.
+            def call(request)
+              span = nil
+
+              # request objects are reused, when already buffered requests get rerouted to a different
+              # connection due to connection issues, or when they already got a response, but need to
+              # be retried. In such situations, the original span needs to be extended for the former,
+              # while a new is required for the latter.
+              request.on(:idle) do
+                span = nil
+              end
+              # the span is initialized when the request is buffered in the parser, which is the closest
+              # one gets to actually sending the request.
+              request.on(:headers) do
+                next if span
+
+                span = initialize_span(request)
+              end
+
+              request.on(:response) do |response|
+                unless span
+                  next unless response.is_a?(::HTTPX::ErrorResponse) && response.error.respond_to?(:connection)
+
+                  # handles the case when the +error+ happened during name resolution, which means
+                  # that the tracing start point hasn't been triggered yet; in such cases, the approximate
+                  # initial resolving time is collected from the connection, and used as span start time,
+                  # and the tracing object in inserted before the on response callback is called.
+                  span = initialize_span(request, response.error.connection.init_time)
+
+                end
+
+                finish(response, span)
+              end
+            end
+
+            def finish(response, span)
+              if response.is_a?(::HTTPX::ErrorResponse)
+                span.record_exception(response.error)
+                span.status = Trace::Status.error(response.error.to_s)
+              else
+                span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response.status)
+                span.set_attribute('http.response.status_code', response.status)
+
+                if response.status.between?(400, 599)
+                  err = ::HTTPX::HTTPError.new(response)
+                  span.record_exception(err)
+                  span.status = Trace::Status.error(err.to_s)
+                end
+              end
+
+              span.finish
+            end
+
+            # return a span initialized with the +@request+ state.
+            def initialize_span(request, start_time = ::Time.now)
+              verb = request.verb
+              uri = request.uri
+
+              config = HTTPX::Instrumentation.instance.config
+
+              attributes = {
+                OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => uri.host,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_METHOD => verb,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => uri.scheme,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => uri.path,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_URL => "#{uri.scheme}://#{uri.host}",
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => uri.host,
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => uri.port,
+                'http.request.method' => verb,
+                'url.scheme' => uri.scheme,
+                'url.path' => uri.path,
+                'url.full' => "#{uri.scheme}://#{uri.host}",
+                'server.address' => uri.host,
+                'server.port' => uri.port
+              }
+
+              attributes['url.query'] = uri.query unless uri.query.nil?
+              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
+              attributes.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+
+              span = tracer.start_span(verb, attributes: attributes, kind: :client, start_timestamp: start_time)
+
+              OpenTelemetry::Trace.with_span(span) do
+                OpenTelemetry.propagation.inject(request.headers)
+              end
+
+              span
+            rescue StandardError => e
+              OpenTelemetry.handle_error(exception: e)
+            end
+
+            def tracer
+              HTTPX::Instrumentation.instance.tracer
+            end
+          end
+
+          # Request patch to initiate the trace on initialization.
+          module RequestMethods
+            def initialize(*)
+              super
+
+              RequestTracer.call(self)
+            end
+          end
+
+          # Connection patch to start monitoring on initialization.
+          module ConnectionMethods
+            attr_reader :init_time
+
+            def initialize(*)
+              super
+
+              @init_time = ::Time.now
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/httpx/instrumentation.rb

@@ -10,8 +10,9 @@ module OpenTelemetry
       # The Instrumentation class contains logic to detect and install the Http instrumentation
       class Instrumentation < OpenTelemetry::Instrumentation::Base
         install do |_config|
-          require_dependencies
-          patch
+          patch_type = determine_semconv
+          send(:"require_dependencies_#{patch_type}")
+          send(:"patch_#{patch_type}")
         end
 
         compatible do
@@ -24,15 +25,50 @@ module OpenTelemetry
 
         option :peer_service, default: nil, validate: :string
 
-        def patch
-          otel_session = ::HTTPX.plugin(Plugin)
+        def determine_semconv
+          stability_opt_in = ENV.fetch('OTEL_SEMCONV_STABILITY_OPT_IN', '')
+          values = stability_opt_in.split(',').map(&:strip)
+
+          if values.include?('http/dup')
+            'dup'
+          elsif values.include?('http')
+            'stable'
+          else
+            'old'
+          end
+        end
+
+        def patch_old
+          otel_session = ::HTTPX.plugin(Old::Plugin)
 
           ::HTTPX.send(:remove_const, :Session)
           ::HTTPX.send(:const_set, :Session, otel_session.class)
         end
 
-        def require_dependencies
-          require_relative 'plugin'
+        def patch_stable
+          otel_session = ::HTTPX.plugin(Stable::Plugin)
+
+          ::HTTPX.send(:remove_const, :Session)
+          ::HTTPX.send(:const_set, :Session, otel_session.class)
+        end
+
+        def patch_dup
+          otel_session = ::HTTPX.plugin(Dup::Plugin)
+
+          ::HTTPX.send(:remove_const, :Session)
+          ::HTTPX.send(:const_set, :Session, otel_session.class)
+        end
+
+        def require_dependencies_old
+          require_relative 'old/plugin'
+        end
+
+        def require_dependencies_stable
+          require_relative 'stable/plugin'
+        end
+
+        def require_dependencies_dup
+          require_relative 'dup/plugin'
         end
       end
     end

data/lib/opentelemetry/instrumentation/httpx/old/plugin.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module HTTPX
+      module Old
+        module Plugin
+          # Instruments around HTTPX's request/response lifecycle in order to generate
+          # an OTEL trace.
+          module RequestTracer
+            module_function
+
+            # initializes tracing on the +request+.
+            def call(request)
+              span = nil
+
+              # request objects are reused, when already buffered requests get rerouted to a different
+              # connection due to connection issues, or when they already got a response, but need to
+              # be retried. In such situations, the original span needs to be extended for the former,
+              # while a new is required for the latter.
+              request.on(:idle) do
+                span = nil
+              end
+              # the span is initialized when the request is buffered in the parser, which is the closest
+              # one gets to actually sending the request.
+              request.on(:headers) do
+                next if span
+
+                span = initialize_span(request)
+              end
+
+              request.on(:response) do |response|
+                unless span
+                  next unless response.is_a?(::HTTPX::ErrorResponse) && response.error.respond_to?(:connection)
+
+                  # handles the case when the +error+ happened during name resolution, which means
+                  # that the tracing start point hasn't been triggered yet; in such cases, the approximate
+                  # initial resolving time is collected from the connection, and used as span start time,
+                  # and the tracing object in inserted before the on response callback is called.
+                  span = initialize_span(request, response.error.connection.init_time)
+
+                end
+
+                finish(response, span)
+              end
+            end
+
+            def finish(response, span)
+              if response.is_a?(::HTTPX::ErrorResponse)
+                span.record_exception(response.error)
+                span.status = Trace::Status.error(response.error.to_s)
+              else
+                span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response.status)
+
+                if response.status.between?(400, 599)
+                  err = ::HTTPX::HTTPError.new(response)
+                  span.record_exception(err)
+                  span.status = Trace::Status.error(err.to_s)
+                end
+              end
+
+              span.finish
+            end
+
+            # return a span initialized with the +@request+ state.
+            def initialize_span(request, start_time = ::Time.now)
+              verb = request.verb
+              uri = request.uri
+
+              config = HTTPX::Instrumentation.instance.config
+
+              attributes = {
+                OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => uri.host,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_METHOD => verb,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => uri.scheme,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => uri.path,
+                OpenTelemetry::SemanticConventions::Trace::HTTP_URL => "#{uri.scheme}://#{uri.host}",
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => uri.host,
+                OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => uri.port
+              }
+
+              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
+              attributes.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+
+              span = tracer.start_span("HTTP #{verb}", attributes: attributes, kind: :client, start_timestamp: start_time)
+
+              OpenTelemetry::Trace.with_span(span) do
+                OpenTelemetry.propagation.inject(request.headers)
+              end
+
+              span
+            rescue StandardError => e
+              OpenTelemetry.handle_error(exception: e)
+            end
+
+            def tracer
+              HTTPX::Instrumentation.instance.tracer
+            end
+          end
+
+          # Request patch to initiate the trace on initialization.
+          module RequestMethods
+            def initialize(*)
+              super
+
+              RequestTracer.call(self)
+            end
+          end
+
+          # Connection patch to start monitoring on initialization.
+          module ConnectionMethods
+            attr_reader :init_time
+
+            def initialize(*)
+              super
+
+              @init_time = ::Time.now
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/httpx/stable/plugin.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module HTTPX
+      module Stable
+        module Plugin
+          # Instruments around HTTPX's request/response lifecycle in order to generate
+          # an OTEL trace.
+          module RequestTracer
+            module_function
+
+            # initializes tracing on the +request+.
+            def call(request)
+              span = nil
+
+              # request objects are reused, when already buffered requests get rerouted to a different
+              # connection due to connection issues, or when they already got a response, but need to
+              # be retried. In such situations, the original span needs to be extended for the former,
+              # while a new is required for the latter.
+              request.on(:idle) do
+                span = nil
+              end
+              # the span is initialized when the request is buffered in the parser, which is the closest
+              # one gets to actually sending the request.
+              request.on(:headers) do
+                next if span
+
+                span = initialize_span(request)
+              end
+
+              request.on(:response) do |response|
+                unless span
+                  next unless response.is_a?(::HTTPX::ErrorResponse) && response.error.respond_to?(:connection)
+
+                  # handles the case when the +error+ happened during name resolution, which means
+                  # that the tracing start point hasn't been triggered yet; in such cases, the approximate
+                  # initial resolving time is collected from the connection, and used as span start time,
+                  # and the tracing object in inserted before the on response callback is called.
+                  span = initialize_span(request, response.error.connection.init_time)
+
+                end
+
+                finish(response, span)
+              end
+            end
+
+            def finish(response, span)
+              if response.is_a?(::HTTPX::ErrorResponse)
+                span.record_exception(response.error)
+                span.status = Trace::Status.error(response.error.to_s)
+              else
+                span.set_attribute('http.response.status_code', response.status)
+
+                if response.status.between?(400, 599)
+                  err = ::HTTPX::HTTPError.new(response)
+                  span.record_exception(err)
+                  span.status = Trace::Status.error(err.to_s)
+                end
+              end
+
+              span.finish
+            end
+
+            # return a span initialized with the +@request+ state.
+            def initialize_span(request, start_time = ::Time.now)
+              verb = request.verb
+              uri = request.uri
+
+              config = HTTPX::Instrumentation.instance.config
+
+              attributes = {
+                'http.request.method' => verb,
+                'url.scheme' => uri.scheme,
+                'url.path' => uri.path,
+                'url.full' => "#{uri.scheme}://#{uri.host}",
+                'server.address' => uri.host,
+                'server.port' => uri.port
+              }
+              attributes['url.query'] = uri.query unless uri.query.nil?
+              attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
+              attributes.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+
+              span = tracer.start_span(verb, attributes: attributes, kind: :client, start_timestamp: start_time)
+
+              OpenTelemetry::Trace.with_span(span) do
+                OpenTelemetry.propagation.inject(request.headers)
+              end
+
+              span
+            rescue StandardError => e
+              OpenTelemetry.handle_error(exception: e)
+            end
+
+            def tracer
+              HTTPX::Instrumentation.instance.tracer
+            end
+          end
+
+          # Request patch to initiate the trace on initialization.
+          module RequestMethods
+            def initialize(*)
+              super
+
+              RequestTracer.call(self)
+            end
+          end
+
+          # Connection patch to start monitoring on initialization.
+          module ConnectionMethods
+            attr_reader :init_time
+
+            def initialize(*)
+              super
+
+              @init_time = ::Time.now
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/httpx/version.rb

@@ -7,7 +7,7 @@
 module OpenTelemetry
   module Instrumentation
     module HTTPX
-      VERSION = '0.2.0'
+      VERSION = '0.3.0'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-instrumentation-httpx
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-16 00:00:00.000000000 Z
+date: 2025-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -38,174 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.23.0
-- !ruby/object:Gem::Dependency
-  name: appraisal
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.4'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: opentelemetry-sdk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: opentelemetry-test-helpers
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rspec-mocks
-  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'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.69.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.69.1
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.23.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.23.0
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.17.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.17.1
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.24.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.24.0
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
 description: HTTPX instrumentation for the OpenTelemetry framework
 email:
 - cncf-opentelemetry-contributors@lists.cncf.io
@@ -220,17 +52,19 @@ files:
 - lib/opentelemetry-instrumentation-httpx.rb
 - lib/opentelemetry/instrumentation.rb
 - lib/opentelemetry/instrumentation/httpx.rb
+- lib/opentelemetry/instrumentation/httpx/dup/plugin.rb
 - lib/opentelemetry/instrumentation/httpx/instrumentation.rb
-- lib/opentelemetry/instrumentation/httpx/plugin.rb
+- lib/opentelemetry/instrumentation/httpx/old/plugin.rb
+- lib/opentelemetry/instrumentation/httpx/stable/plugin.rb
 - lib/opentelemetry/instrumentation/httpx/version.rb
 homepage: https://github.com/open-telemetry/opentelemetry-ruby-contrib
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-httpx/0.2.0/file/CHANGELOG.md
+  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-httpx/0.3.0/file/CHANGELOG.md
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/tree/main/instrumentation/http
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/issues
-  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-httpx/0.2.0
+  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-httpx/0.3.0
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/opentelemetry/instrumentation/httpx/plugin.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module Instrumentation
-    module HTTPX
-      module Plugin
-        # Instruments around HTTPX's request/response lifecycle in order to generate
-        # an OTEL trace.
-        class RequestTracer
-          # Constant for the HTTP status range
-          HTTP_STATUS_SUCCESS_RANGE = (100..399)
-
-          def initialize(request)
-            @request = request
-          end
-
-          def call
-            @request.on(:response, &method(:finish)) # rubocop:disable Performance/MethodObjectAsBlock
-
-            uri = @request.uri
-            request_method = @request.verb
-            span_name = "HTTP #{request_method}"
-
-            attributes = {
-              OpenTelemetry::SemanticConventions::Trace::HTTP_HOST => uri.host,
-              OpenTelemetry::SemanticConventions::Trace::HTTP_METHOD => request_method,
-              OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => uri.scheme,
-              OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => uri.path,
-              OpenTelemetry::SemanticConventions::Trace::HTTP_URL => "#{uri.scheme}://#{uri.host}",
-              OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => uri.host,
-              OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => uri.port
-            }
-            config = HTTPX::Instrumentation.instance.config
-            attributes[OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] if config[:peer_service]
-            attributes.merge!(
-              OpenTelemetry::Common::HTTP::ClientContext.attributes
-            )
-
-            @span = tracer.start_span(span_name, attributes: attributes, kind: :client)
-            trace_ctx = OpenTelemetry::Trace.context_with_span(@span)
-            @trace_token = OpenTelemetry::Context.attach(trace_ctx)
-
-            OpenTelemetry.propagation.inject(@request.headers)
-          rescue StandardError => e
-            OpenTelemetry.handle_error(exception: e)
-          end
-
-          def finish(response)
-            return unless @span
-
-            if response.is_a?(::HTTPX::ErrorResponse)
-              @span.record_exception(response.error)
-              @span.status = Trace::Status.error("Unhandled exception of type: #{response.error.class}")
-            else
-              @span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE, response.status)
-              @span.status = Trace::Status.error unless HTTP_STATUS_SUCCESS_RANGE.cover?(response.status)
-            end
-
-            OpenTelemetry::Context.detach(@trace_token) if @trace_token
-            @span.finish
-          end
-
-          private
-
-          def tracer
-            HTTPX::Instrumentation.instance.tracer
-          end
-        end
-
-        # HTTPX::Request overrides
-        module RequestMethods
-          def __otel_enable_trace!
-            return if @__otel_enable_trace
-
-            RequestTracer.new(self).call
-            @__otel_enable_trace = true
-          end
-        end
-
-        # HTTPX::Connection overrides
-        module ConnectionMethods
-          def send(request)
-            request.__otel_enable_trace!
-
-            super
-          end
-        end
-      end
-    end
-  end
-end