fix: add readme and rubocop fix

Author: hannahramadan

instrumentation/rack/README.md

@@ -101,3 +101,19 @@ The `opentelemetry-instrumentation-rack` gem is distributed under the Apache 2.0
 [community-meetings]: https://github.com/open-telemetry/community#community-meetings
 [slack-channel]: https://cloud-native.slack.com/archives/C01NWKKMKMY
 [discussions-url]: https://github.com/open-telemetry/opentelemetry-ruby/discussions
+
+## HTTP semantic convention stability
+
+In the OpenTelemetry ecosystem, HTTP semantic conventions have now reached a stable state. However, the initial Rack 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, Rack instrumentation code comes in three patch versions: `dup`, `old`, and `stable`. These versions are identical except for the attributes they send. Any changes to Rack 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/).

instrumentation/rack/lib/opentelemetry/instrumentation/rack/middlewares/dup/event_handler.rb

@@ -128,7 +128,7 @@ def extract_request_headers(env)
             end
 
             def extract_response_attributes(response)
-              attributes = { 
+              attributes = {
                 'http.status_code' => response.status.to_i,
                 'http.response.status_code' => response.status.to_i
               }

instrumentation/rack/lib/opentelemetry/instrumentation/rack/middlewares/old/event_handler.rb

@@ -42,10 +42,10 @@ module Old
           # @see OpenTelemetry::Instrumentation::Rack.current_span
           class EventHandler
             include ::Rack::Events::Abstract
-  
+
             OTEL_TOKEN_AND_SPAN = 'otel.rack.token_and_span'
             EMPTY_HASH = {}.freeze
-  
+
             # Creates a server span for this current request using the incoming parent context
             # and registers them as the {current_span}
             #
@@ -58,15 +58,15 @@ def on_start(request, _)
                                else
                                  extract_remote_context(request)
                                end
-  
+
               span = create_span(parent_context, request)
               span_ctx = OpenTelemetry::Trace.context_with_span(span, parent_context: parent_context)
               rack_ctx = OpenTelemetry::Instrumentation::Rack.context_with_span(span, parent_context: span_ctx)
               request.env[OTEL_TOKEN_AND_SPAN] = [OpenTelemetry::Context.attach(rack_ctx), span]
             rescue StandardError => e
               OpenTelemetry.handle_error(exception: e)
             end
-  
+
             # Optionally adds debugging response headers injected from {response_propagators}
             #
             # @param [Rack::Request] The current HTTP request
@@ -75,7 +75,7 @@ def on_start(request, _)
             def on_commit(request, response)
               span = OpenTelemetry::Instrumentation::Rack.current_span
               return unless span.recording?
-  
+
               response_propagators&.each do |propagator|
                 propagator.inject(response.headers)
               rescue StandardError => e
@@ -84,7 +84,7 @@ def on_commit(request, response)
             rescue StandardError => e
               OpenTelemetry.handle_error(exception: e)
             end
-  
+
             # Records Unexpected Exceptions on the Rack span and set the Span Status to Error
             #
             # @note does nothing if the span is a non-recording span
@@ -94,13 +94,13 @@ def on_commit(request, response)
             def on_error(request, _, error)
               span = OpenTelemetry::Instrumentation::Rack.current_span
               return unless span.recording?
-  
+
               span.record_exception(error)
               span.status = OpenTelemetry::Trace::Status.error(error.class.name)
             rescue StandardError => e
               OpenTelemetry.handle_error(exception: e)
             end
-  
+
             # Finishes the span making it eligible to be exported and cleans up existing contexts
             #
             # @note does nothing if the span is a non-recording span
@@ -109,33 +109,33 @@ def on_error(request, _, error)
             def on_finish(request, response)
               span = OpenTelemetry::Instrumentation::Rack.current_span
               return unless span.recording?
-  
+
               add_response_attributes(span, response) if response
             rescue StandardError => e
               OpenTelemetry.handle_error(exception: e)
             ensure
               detach_context(request)
             end
-  
+
             private
-  
+
             def extract_request_headers(env)
               return EMPTY_HASH if allowed_request_headers.empty?
-  
+
               allowed_request_headers.each_with_object({}) do |(key, value), result|
                 result[value] = env[key] if env.key?(key)
               end
             end
-  
+
             def extract_response_attributes(response)
               attributes = { 'http.status_code' => response.status.to_i }
               attributes.merge!(extract_response_headers(response.headers))
               attributes
             end
-  
+
             def extract_response_headers(headers)
               return EMPTY_HASH if allowed_response_headers.empty?
-  
+
               allowed_response_headers.each_with_object({}) do |(key, value), result|
                 if headers.key?(key)
                   result[value] = headers[key]
@@ -150,14 +150,14 @@ def extract_response_headers(headers)
                 end
               end
             end
-  
+
             def untraced_request?(env)
               return true if untraced_endpoints.include?(env['PATH_INFO'])
               return true if untraced_requests&.call(env)
-  
+
               false
             end
-  
+
             # https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-http.md#name
             #
             # recommendation: span.name(s) should be low-cardinality (e.g.,
@@ -167,90 +167,90 @@ def untraced_request?(env)
             def create_request_span_name(request)
               # NOTE: dd-trace-rb has implemented 'quantization' (which lowers url cardinality)
               #       see Datadog::Quantization::HTTP.url
-  
+
               if (implementation = url_quantization)
                 request_uri_or_path_info = request.env['REQUEST_URI'] || request.path_info
                 implementation.call(request_uri_or_path_info, request.env)
               else
                 "HTTP #{request.request_method}"
               end
             end
-  
+
             def extract_remote_context(request, context = Context.current)
               OpenTelemetry.propagation.extract(
                 request.env,
                 context: context,
                 getter: OpenTelemetry::Common::Propagation.rack_env_getter
               )
             end
-  
+
             def request_span_attributes(env)
               attributes = {
                 'http.method' => env['REQUEST_METHOD'],
                 'http.host' => env['HTTP_HOST'] || 'unknown',
                 'http.scheme' => env['rack.url_scheme'],
                 'http.target' => env['QUERY_STRING'].empty? ? env['PATH_INFO'] : "#{env['PATH_INFO']}?#{env['QUERY_STRING']}"
               }
-  
+
               attributes['http.user_agent'] = env['HTTP_USER_AGENT'] if env['HTTP_USER_AGENT']
               attributes.merge!(extract_request_headers(env))
               attributes
             end
-  
+
             def detach_context(request)
               return nil unless request.env[OTEL_TOKEN_AND_SPAN]
-  
+
               token, span = request.env[OTEL_TOKEN_AND_SPAN]
               span.finish
               OpenTelemetry::Context.detach(token)
             rescue StandardError => e
               OpenTelemetry.handle_error(exception: e)
             end
-  
+
             def add_response_attributes(span, response)
               span.status = OpenTelemetry::Trace::Status.error if response.server_error?
               attributes = extract_response_attributes(response)
               span.add_attributes(attributes)
             rescue StandardError => e
               OpenTelemetry.handle_error(exception: e)
             end
-  
+
             def record_frontend_span?
               config[:record_frontend_span] == true
             end
-  
+
             def untraced_endpoints
               config[:untraced_endpoints]
             end
-  
+
             def untraced_requests
               config[:untraced_requests]
             end
-  
+
             def url_quantization
               config[:url_quantization]
             end
-  
+
             def response_propagators
               config[:response_propagators]
             end
-  
+
             def allowed_request_headers
               config[:allowed_rack_request_headers]
             end
-  
+
             def allowed_response_headers
               config[:allowed_rack_response_headers]
             end
-  
+
             def tracer
               OpenTelemetry::Instrumentation::Rack::Instrumentation.instance.tracer
             end
-  
+
             def config
               OpenTelemetry::Instrumentation::Rack::Instrumentation.instance.config
             end
-  
+
             def create_span(parent_context, request)
               span = tracer.start_span(
                 create_request_span_name(request),

instrumentation/rack/test/opentelemetry/instrumentation/rack/middlewares/dup/event_handler_test.rb

@@ -234,7 +234,7 @@
 
           root_span = finished_spans.find { |s| s.attributes['http.target'] == '/' }
           root_span_stable = finished_spans.find { |s| s.attributes['url.path'] == '/' }
-          
+
           _(root_span).wont_be_nil
           _(root_span_stable).wont_be_nil
         end