hypertrace-agent 0.1.0

data/lib/hypertrace/config/config.rb

@@ -0,0 +1,77 @@
+require 'yaml'
+class Hypertrace::Config::Config
+  include Hypertrace::Logging
+  attr_reader :config
+  def initialize
+    @config = load_config
+  end
+
+  def load_config
+    # Order of loading:
+    # 1.) Defaults
+    # 2.) Overriden by config file
+    # 3.) Overriden by env vars
+    config = Marshal.load(Marshal.dump(DEFAULT_AGENT_CONFIG))
+
+    file_config = load_file
+    config = merge_config(config, file_config)
+
+    env_config = Hypertrace::Config::Environment.load_config_from_env
+    config = merge_config(config, env_config)
+
+    log.info "Finalized config loaded"
+    log.info config
+
+    proto_config = Hypertrace::Agent::Config::V1::AgentConfig.new
+    enabled = Google::Protobuf::BoolValue.new({value: config[:enabled]})
+    proto_config.enabled = enabled
+    proto_config.propagation_formats += config[:propagation_formats]
+    service_name = Google::Protobuf::StringValue.new({value: config[:service_name]})
+    proto_config.service_name = service_name
+
+    proto_config.reporting = Hypertrace::Agent::Config::V1::Reporting.new
+    endpoint = Google::Protobuf::StringValue.new({value: config[:reporting][:endpoint]})
+    proto_config.reporting.endpoint = endpoint
+    secure = Google::Protobuf::BoolValue.new({value: config[:reporting][:secure]})
+    proto_config.reporting.secure = secure
+
+    proto_config.reporting.trace_reporter_type = config[:reporting][:trace_reporter_type]
+
+    proto_config.data_capture = Hypertrace::Agent::Config::V1::DataCapture.new
+    %i[http_headers http_body rpc_metadata rpc_body].each do |field|
+      message_instance = Hypertrace::Agent::Config::V1::Message.new
+      message_instance.request = Google::Protobuf::BoolValue.new({value:config[:data_capture][field][:request]})
+      message_instance.response = Google::Protobuf::BoolValue.new({value:config[:data_capture][field][:response]})
+      proto_config.data_capture[field.to_s] = message_instance
+    end
+    proto_config.data_capture.body_max_size_bytes = Google::Protobuf::Int32Value.new({value: config[:data_capture][:body_max_size_bytes]})
+
+    proto_config.resource_attributes.merge(config[:resource_attributes])
+    proto_config
+  end
+
+  def load_file
+    file_path = Hypertrace::EnvVarSettings.env_value('CONFIG_FILE')
+    return {} if file_path.nil?
+
+    begin
+      yaml_content = File.read(file_path)
+      config_file_contents = YAML.load(yaml_content, symbolize_names: true)
+    rescue => e
+      log.warn "failed to load config file: #{file_path}"
+    end
+    config_file_contents || {}
+  end
+
+  def merge_config(base_config, overriding_config)
+    overriding_config.each_key do |key|
+      if base_config.key?(key) && base_config[key].instance_of?(Hash)
+        base_config[key] = merge_config(base_config[key], overriding_config[key])
+      else
+        base_config[key] = overriding_config[key]
+      end
+    end
+
+    base_config
+  end
+end

data/lib/hypertrace/config/config_pb.rb

@@ -0,0 +1,78 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: config.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/wrappers_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("config.proto", :syntax => :proto3) do
+    add_message "hypertrace.agent.config.v1.AgentConfig" do
+      optional :service_name, :message, 1, "google.protobuf.StringValue"
+      optional :reporting, :message, 2, "hypertrace.agent.config.v1.Reporting"
+      optional :data_capture, :message, 3, "hypertrace.agent.config.v1.DataCapture"
+      repeated :propagation_formats, :enum, 4, "hypertrace.agent.config.v1.PropagationFormat"
+      optional :enabled, :message, 5, "google.protobuf.BoolValue"
+      optional :javaagent, :message, 6, "hypertrace.agent.config.v1.JavaAgent"
+      map :resource_attributes, :string, :string, 7
+    end
+    add_message "hypertrace.agent.config.v1.Reporting" do
+      optional :endpoint, :message, 1, "google.protobuf.StringValue"
+      optional :secure, :message, 2, "google.protobuf.BoolValue"
+      optional :token, :message, 3, "google.protobuf.StringValue"
+      optional :trace_reporter_type, :enum, 5, "hypertrace.agent.config.v1.TraceReporterType"
+      optional :cert_file, :message, 6, "google.protobuf.StringValue"
+      optional :metric_endpoint, :message, 7, "google.protobuf.StringValue"
+      optional :metric_reporter_type, :enum, 8, "hypertrace.agent.config.v1.MetricReporterType"
+    end
+    add_message "hypertrace.agent.config.v1.Message" do
+      optional :request, :message, 1, "google.protobuf.BoolValue"
+      optional :response, :message, 2, "google.protobuf.BoolValue"
+    end
+    add_message "hypertrace.agent.config.v1.DataCapture" do
+      optional :http_headers, :message, 1, "hypertrace.agent.config.v1.Message"
+      optional :http_body, :message, 2, "hypertrace.agent.config.v1.Message"
+      optional :rpc_metadata, :message, 3, "hypertrace.agent.config.v1.Message"
+      optional :rpc_body, :message, 4, "hypertrace.agent.config.v1.Message"
+      optional :body_max_size_bytes, :message, 5, "google.protobuf.Int32Value"
+      optional :body_max_processing_size_bytes, :message, 6, "google.protobuf.Int32Value"
+    end
+    add_message "hypertrace.agent.config.v1.JavaAgent" do
+      repeated :filter_jar_paths, :message, 1, "google.protobuf.StringValue"
+    end
+    add_enum "hypertrace.agent.config.v1.PropagationFormat" do
+      value :B3, 0
+      value :TRACECONTEXT, 1
+    end
+    add_enum "hypertrace.agent.config.v1.TraceReporterType" do
+      value :UNSPECIFIED, 0
+      value :ZIPKIN, 1
+      value :OTLP, 2
+      value :LOGGING, 3
+      value :NONE, 4
+    end
+    add_enum "hypertrace.agent.config.v1.MetricReporterType" do
+      value :METRIC_REPORTER_TYPE_UNSPECIFIED, 0
+      value :METRIC_REPORTER_TYPE_OTLP, 1
+      value :METRIC_REPORTER_TYPE_PROMETHEUS, 2
+      value :METRIC_REPORTER_TYPE_LOGGING, 3
+      value :METRIC_REPORTER_TYPE_NONE, 4
+    end
+  end
+end
+
+module Hypertrace
+  module Agent
+    module Config
+      module V1
+        AgentConfig = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("hypertrace.agent.config.v1.AgentConfig").msgclass
+        Reporting = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("hypertrace.agent.config.v1.Reporting").msgclass
+        Message = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("hypertrace.agent.config.v1.Message").msgclass
+        DataCapture = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("hypertrace.agent.config.v1.DataCapture").msgclass
+        JavaAgent = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("hypertrace.agent.config.v1.JavaAgent").msgclass
+        PropagationFormat = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("hypertrace.agent.config.v1.PropagationFormat").enummodule
+        TraceReporterType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("hypertrace.agent.config.v1.TraceReporterType").enummodule
+        MetricReporterType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("hypertrace.agent.config.v1.MetricReporterType").enummodule
+      end
+    end
+  end
+end

data/lib/hypertrace/config/default.rb

@@ -0,0 +1,31 @@
+DEFAULT_AGENT_CONFIG = {
+  'enabled': true,
+  'propagation_formats': ['TRACECONTEXT'],
+  'service_name': 'rubyagent',
+  'reporting': {
+    'endpoint': 'http://localhost:4318/v1/traces',
+    'secure': false,
+    'trace_reporter_type': 'OTLP',
+    'token': '',
+  },
+  'data_capture': {
+    'http_headers': {
+      'request': true,
+      'response': true,
+    },
+    'http_body': {
+      'request': true,
+      'response': true,
+    },
+    'rpc_metadata': {
+      'request': true,
+      'response': true,
+    },
+    'rpc_body': {
+      'request': true,
+      'response': true,
+    },
+    'body_max_size_bytes': 131072
+  },
+  'resource_attributes': {}
+}.freeze

data/lib/hypertrace/config/environment.rb

@@ -0,0 +1,142 @@
+module Hypertrace::Config::Environment
+  class << self
+    include Hypertrace::Logging
+
+    def load_config_from_env
+      config = {}
+
+      service_name = Hypertrace::EnvVarSettings.env_value('SERVICE_NAME')
+      if service_name
+        log.debug "[env] Loaded SERVICE_NAME from env"
+        config[:service_name] = service_name
+      end
+
+      # Reporting
+      config[:reporting] = {}
+      reporting_endpoint = Hypertrace::EnvVarSettings.env_value('REPORTING_ENDPOINT')
+      if reporting_endpoint
+        log.debug "[env] Loaded REPORTING_ENDPOINT from env"
+        config[:reporting][:endpoint] = reporting_endpoint
+      end
+
+      reporter_type = Hypertrace::EnvVarSettings.env_value('REPORTING_TRACE_REPORTER_TYPE')
+      if reporter_type
+        log.debug "[env] Loaded REPORTING_TRACE_REPORTER_TYPE from env"
+        config[:reporting][:trace_reporter_type] = reporter_type
+      end
+
+      reporting_secure = Hypertrace::EnvVarSettings.env_value('REPORTING_SECURE')
+      if reporting_secure
+        log.debug "[env] Loaded REPORTING_SECURE from env"
+        config[:reporting][:secure] = is_true(reporting_secure)
+      end
+
+      reporting_token = Hypertrace::EnvVarSettings.env_value('REPORTING_TOKEN')
+      if reporting_token
+        log.debug("[env] Loaded REPORTING_TOKEN from env")
+        config[:reporting][:token] = reporting_token
+      end
+
+      config.delete(:reporting) if config[:reporting].empty?
+
+      # Data capture
+      config[:data_capture] = {}
+
+      config[:data_capture][:http_headers] = {}
+      headers_request = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_HTTP_HEADERS_REQUEST')
+      if headers_request
+        log.debug("[env] Loaded DATA_CAPTURE_HTTP_HEADERS_REQUEST from env")
+        config[:data_capture][:http_headers][:request] = is_true(headers_request)
+      end
+
+      headers_response = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_HTTP_HEADERS_RESPONSE')
+      if headers_response
+        log.debug("[env] Loaded DATA_CAPTURE_HTTP_HEADERS_RESPONSE from env")
+        config[:data_capture][:http_headers][:response] = is_true(headers_response)
+      end
+
+      config[:data_capture].delete(:http_headers) if config[:data_capture][:http_headers].empty?
+
+      config[:data_capture][:http_body] = {}
+      body_request = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_HTTP_BODY_REQUEST')
+      if body_request
+        log.debug("[env] Loaded DATA_CAPTURE_HTTP_BODY_REQUEST from env")
+        config[:data_capture][:http_body][:request] = is_true(body_request)
+      end
+
+      body_response = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_HTTP_BODY_RESPONSE')
+      if body_response
+        log.debug("[env] Loaded DATA_CAPTURE_HTTP_BODY_RESPONSE from env")
+        config[:data_capture][:http_body][:response] = is_true(body_response)
+      end
+
+      config[:data_capture].delete(:http_body) if config[:data_capture][:http_body].empty?
+
+      config[:data_capture][:rpc_metadata] = {}
+      rpc_metadata_request = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_RPC_METADATA_REQUEST')
+      if rpc_metadata_request
+        log.debug("[env] Loaded DATA_CAPTURE_RPC_METADATA_REQUEST from env")
+        config[:data_capture][:rpc_metadata][:request] = is_true(rpc_metadata_request)
+      end
+
+      rpc_metadata_response = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_RPC_METADATA_RESPONSE')
+      if rpc_metadata_response
+        log.debug("[env] Loaded DATA_CAPTURE_RPC_METADATA_RESPONSE from env")
+        config[:data_capture][:rpc_metadata][:response] = is_true(rpc_metadata_response)
+      end
+      config[:data_capture].delete(:rpc_metadata) if config[:data_capture][:rpc_metadata].empty?
+
+      config[:data_capture][:rpc_body] = {}
+      rpc_body_request = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_RPC_BODY_REQUEST')
+      if rpc_body_request
+        log.debug("[env] Loaded DATA_CAPTURE_RPC_BODY_REQUEST from env")
+        config[:data_capture][:rpc_body][:request] = is_true(rpc_body_request)
+      end
+
+      rpc_body_response = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_RPC_BODY_RESPONSE')
+      if rpc_body_response
+        log.debug("[env] Loaded DATA_CAPTURE_RPC_BODY_RESPONSE from env")
+        config[:data_capture][:rpc_body][:response] = is_true(rpc_body_response)
+      end
+      config[:data_capture].delete(:rpc_body) if config[:data_capture][:rpc_body].empty?
+
+      body_max_size_bytes = Hypertrace::EnvVarSettings.env_value('DATA_CAPTURE_BODY_MAX_SIZE_BYTES')
+      if body_max_size_bytes
+        log.debug("[env] Loaded DATA_CAPTURE_BODY_MAX_SIZE_BYTES from env")
+        config[:data_capture][:body_max_size_bytes] = body_max_size_bytes.to_i
+      end
+
+      config.delete(:data_capture) if config[:data_capture].empty?
+
+      propagation_formats = Hypertrace::EnvVarSettings.env_value(:propagation_formats)
+      if propagation_formats && propagation_formats.length > 0
+        log.debug("[env] Loaded PROPAGATION_FORMATS from env")
+        config[:propagation_formats] = propagation_formats.split(',')
+      end
+
+      enabled = Hypertrace::EnvVarSettings.env_value(:enabled)
+      if enabled
+        log.debug("[env] Loaded ENABLED from env")
+        config[:enabled] = is_true(enabled)
+      end
+
+      resource_attributes = Hypertrace::EnvVarSettings.env_value(:resource_attributes)
+      if resource_attributes
+        config[:resource_attributes] = {}
+        log.debug('[env] Loaded RESOURCE_ATTRIBUTES from env')
+        groups = resource_attributes.split(',')
+        groups.each do |group|
+          key, value = group.split('=')
+          config[:resource_attributes][key] = value
+        end
+      end
+
+      return config
+    end
+
+    def is_true value
+      value.downcase == 'true'
+    end
+  end
+
+end

data/lib/hypertrace/config.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Hypertrace::Config
+  require_relative './config/default'
+  require_relative './config/environment'
+  require_relative './config/config_pb'
+  require_relative './config/config'
+end

data/lib/hypertrace/env_var_settings.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Hypertrace::EnvVarSettings
+  PREFIXES = ['HT']
+  class << self
+    def env_value target_key
+      PREFIXES.each do |prefix|
+        key = "#{prefix}_#{target_key}"
+        return ENV[key] if ENV.key?(key)
+      end
+      nil
+    end
+  end
+end

data/lib/hypertrace/instrumentation/data_capture.rb

@@ -0,0 +1,57 @@
+class Hypertrace::Instrumentation::DataCapture
+  TYPE_REQUEST = 'request'
+  TYPE_RESPONSE = 'response'
+  CONTENT_TYPE_SUBSTRINGS = %w[json x-www-form-urlencoded]
+
+  def self.headers_to_attribute_keys header_hash, type, &block
+    return {} unless header_allowed_by_config?(type)
+
+    attrs = {}
+    header_hash.each do |header_key, header_value|
+      attr_key = "http.#{type}.header.#{header_key.downcase}"
+      header_value = header_value.join(',') if header_value.is_a?(Array)
+      if block_given?
+        yield attr_key, header_value
+      else
+        attrs[attr_key] = header_value
+      end
+    end
+    return if block_given?
+    return attrs
+  end
+
+  def self.capturable_body body_object
+    max_capture = Hypertrace::RubyAgent.config.data_capture.body_max_size_bytes.value
+    if body_object.is_a?(String)
+      return body_object.byteslice(0..max_capture)
+    elsif body_object.is_a?(StringIO)
+      result =  body_object.read(max_capture)
+      body_object.rewind
+      return result
+    end
+  end
+
+  def self.can_capture?(content_type, type)
+    return false unless content_type
+    return false unless body_allowed_by_config?(type)
+
+    content_type = content_type.downcase
+    CONTENT_TYPE_SUBSTRINGS.each do |substring|
+      if content_type.include?(substring)
+        return true
+      end
+    end
+    false
+  end
+
+  def self.header_allowed_by_config? type
+    return Hypertrace::RubyAgent.config.data_capture.http_headers.request.value if type == TYPE_REQUEST
+    Hypertrace::RubyAgent.config.data_capture.http_headers.response.value
+  end
+
+  def self.body_allowed_by_config? type
+    return Hypertrace::RubyAgent.config.data_capture.http_body.request.value if type == TYPE_REQUEST
+    Hypertrace::RubyAgent.config.data_capture.http_body.response.value
+  end
+
+end

data/lib/hypertrace/instrumentation/faraday_patch.rb

@@ -0,0 +1,40 @@
+class OpenTelemetry::Instrumentation::Faraday::Middlewares::TracerMiddleware < ::Faraday::Middleware
+  def call(env)
+    http_method = HTTP_METHODS_SYMBOL_TO_STRING[env.method]
+    attributes = span_creation_attributes(
+      http_method: http_method, url: env.url
+    )
+    request_headers = env.request_headers.to_h
+    header_attrs = Hypertrace::Instrumentation::DataCapture.headers_to_attribute_keys(request_headers,
+                                                                                      Hypertrace::Instrumentation::DataCapture::TYPE_REQUEST)
+
+    content_type = request_headers['Content-Type']
+    if Hypertrace::Instrumentation::DataCapture.can_capture?(content_type, Hypertrace::Instrumentation::DataCapture::TYPE_REQUEST)
+      body_cap = Hypertrace::Instrumentation::DataCapture.capturable_body(env&.request_body&.to_s)
+      attributes['http.request.body'] = body_cap if body_cap
+    end
+
+    attributes.merge!(header_attrs)
+    tracer.in_span(
+      "HTTP #{http_method}", attributes: attributes, kind: :client
+    ) do |span|
+      OpenTelemetry.propagation.inject(env.request_headers)
+
+      app.call(env).on_complete do |resp|
+        resp = Faraday::Response.new(resp)
+        resp_headers = resp.headers.to_h
+        Hypertrace::Instrumentation::DataCapture.headers_to_attribute_keys(resp_headers,
+                                                                           Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE) do |k, v|
+          span.set_attribute(k, v)
+        end
+        content_type = resp_headers['content-type']
+        if Hypertrace::Instrumentation::DataCapture.can_capture?(content_type, Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE)
+          body_cap = Hypertrace::Instrumentation::DataCapture.capturable_body(resp.body)
+          span.set_attribute('http.response.body', body_cap) if body_cap
+        end
+
+        trace_response(span, resp)
+      end
+    end
+  end
+end

data/lib/hypertrace/instrumentation/http_patch.rb

@@ -0,0 +1,41 @@
+module OpenTelemetry::Instrumentation::HTTP::Patches::Client
+  def perform(req, options)
+    uri = req.uri
+    request_method = req.verb.to_s.upcase
+
+    headers = req.headers.to_h
+    attrs = Hypertrace::Instrumentation::DataCapture.headers_to_attribute_keys(headers,
+                                                                                      Hypertrace::Instrumentation::DataCapture::TYPE_REQUEST)
+    content_type = headers['Content-Type']
+    if Hypertrace::Instrumentation::DataCapture.can_capture?(content_type, Hypertrace::Instrumentation::DataCapture::TYPE_REQUEST)
+      body_cap = Hypertrace::Instrumentation::DataCapture.capturable_body(req.body.source)
+      attrs['http.request.body'] = body_cap if body_cap
+    end
+
+    attributes = {
+      'http.method' => request_method,
+      'http.scheme' => uri.scheme,
+      'http.target' => uri.path,
+      'http.url' => uri.to_s,
+      'net.peer.name' => uri.host,
+      'net.peer.port' => uri.port
+    }.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes).merge!(attrs)
+
+    tracer.in_span("HTTP #{request_method}", attributes: attributes, kind: :client) do |span|
+      OpenTelemetry.propagation.inject(req.headers)
+      super.tap do |response|
+        response_headers = response.headers.to_h
+        Hypertrace::Instrumentation::DataCapture.headers_to_attribute_keys(response_headers,
+                                                                           Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE) do |k, v|
+          span.set_attribute(k, v)
+        end
+        content_type = response_headers['Content-Type']
+        if Hypertrace::Instrumentation::DataCapture.can_capture?(content_type, Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE)
+          body_cap = Hypertrace::Instrumentation::DataCapture.capturable_body(response.body.to_s)
+          span.set_attribute('http.response.body', body_cap) if body_cap
+        end
+        annotate_span_with_response!(span, response)
+      end
+    end
+  end
+end

data/lib/hypertrace/instrumentation/net_http_patch.rb

@@ -0,0 +1,46 @@
+module OpenTelemetry::Instrumentation::Net::HTTP::Patches::Instrumentation
+  def request(req, body = nil, &block)
+    # Do not trace recursive call for starting the connection
+    return super(req, body, &block) unless started?
+
+    scheme = use_ssl? ? "https://" : "http"
+    url = "#{scheme}#{@address}:#{@port}#{req.path}"
+    attributes = {
+      OpenTelemetry::SemanticConventions::Trace::HTTP_METHOD => req.method,
+      OpenTelemetry::SemanticConventions::Trace::HTTP_SCHEME => USE_SSL_TO_SCHEME[use_ssl?],
+      OpenTelemetry::SemanticConventions::Trace::HTTP_TARGET => req.path,
+      OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => @address,
+      OpenTelemetry::SemanticConventions::Trace::NET_PEER_PORT => @port,
+      OpenTelemetry::SemanticConventions::Trace::HTTP_URL =>  url
+    }.merge!(OpenTelemetry::Common::HTTP::ClientContext.attributes)
+
+    header_map = req.instance_variable_get(:@header)
+    ht_attributes = Hypertrace::Instrumentation::DataCapture.headers_to_attribute_keys(header_map,
+                                                                                      Hypertrace::Instrumentation::DataCapture::TYPE_REQUEST)
+    content_type = header_map['content-type']&.first
+    if Hypertrace::Instrumentation::DataCapture.can_capture?(content_type, Hypertrace::Instrumentation::DataCapture::TYPE_REQUEST)
+      body_cap = Hypertrace::Instrumentation::DataCapture.capturable_body(req.body)
+      ht_attributes['http.request.body'] = body_cap if body_cap
+    end
+    tracer.in_span(
+      HTTP_METHODS_TO_SPAN_NAMES[req.method],
+      attributes: attributes.merge!(ht_attributes),
+      kind: :client
+    ) do |span|
+      OpenTelemetry.propagation.inject(req)
+
+      super(req, body, &block).tap do |response|
+        response_headers = response.instance_variable_get(:@header)
+        Hypertrace::Instrumentation::DataCapture.headers_to_attribute_keys(response_headers,
+                                                                           Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE) do |k, v|
+          span.set_attribute(k, v)
+        end
+        content_type = response_headers['content-type']&.first
+        if Hypertrace::Instrumentation::DataCapture.can_capture?(content_type, Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE)
+          span.set_attribute('http.response.body', Hypertrace::Instrumentation::DataCapture.capturable_body(response.body))
+        end
+        annotate_span_with_response!(span, response)
+      end
+    end
+  end
+end

data/lib/hypertrace/instrumentation/rack.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class OpenTelemetry::Instrumentation::Rack::Middlewares::TracerMiddleware
+  def call(env)
+    if untraced_request?(env)
+      OpenTelemetry::Common::Utilities.untraced do
+        return @app.call(env)
+      end
+    end
+
+    original_env = env.dup
+    extracted_context = OpenTelemetry.propagation.extract(
+      env,
+      getter: OpenTelemetry::Common::Propagation.rack_env_getter
+    )
+    frontend_context = create_frontend_span(env, extracted_context)
+
+    # restore extracted context in this process:
+    OpenTelemetry::Context.with_current(frontend_context || extracted_context) do
+      request_span_name = create_request_span_name(env['REQUEST_URI'] || original_env['PATH_INFO'], env)
+      request_span_kind = frontend_context.nil? ? :server : :internal
+
+      ht_attributes = Hypertrace::Instrumentation::RackCompatible.extract_req_headers_as_attributes(env, 'http.request.header')
+      content_type = env['CONTENT_TYPE']
+      if Hypertrace::Instrumentation::DataCapture.can_capture?(content_type,
+                                                               Hypertrace::Instrumentation::DataCapture::TYPE_REQUEST)
+
+        body_cap = Hypertrace::Instrumentation::DataCapture.capturable_body(env['rack.input'])
+        ht_attributes['http.request.body'] = body_cap if body_cap
+      end
+
+      tracer.in_span(request_span_name,
+                     attributes: request_span_attributes(env: env).merge(ht_attributes),
+                     kind: request_span_kind) do |request_span|
+        OpenTelemetry::Instrumentation::Rack.with_span(request_span) do
+          @app.call(env).tap do |status, headers, response|
+
+            response_headers = headers.to_hash
+            Hypertrace::Instrumentation::DataCapture.headers_to_attribute_keys(response_headers, Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE)
+            response_headers.each do |h_k, h_v|
+              request_span.set_attribute("http.response.header.#{h_k.downcase}", h_v)
+            end
+            content_type_arr = response_headers.find{|x|x[0].downcase == "content-type"}
+            if Hypertrace::Instrumentation::DataCapture.can_capture?(content_type_arr&.join(''),
+                                                                     Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE)
+              cap_body = Hypertrace::Instrumentation::RackCompatible.extract_response_body(response)
+              request_span.set_attribute('http.response.body', cap_body) if cap_body
+            end
+
+            set_attributes_after_request(request_span, status, headers, response)
+          end
+        end
+      end
+    end
+  ensure
+    finish_span(frontend_context)
+  end
+end

data/lib/hypertrace/instrumentation/rack_compatible.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Hypertrace
+  module Instrumentation
+    class RackCompatible
+
+      CONTENT_TYPE_SUBSTRINGS = %w[json x-www-form-urlencoded]
+
+      def self.extract_req_headers_as_attributes env, attr_prefix
+        return unless Hypertrace::RubyAgent.instance.config.data_capture.http_headers.request
+
+        headers = extract_headers_from_env(env)
+        attr_hash = headers.map do |key, value|
+          # https://github.com/rails/rails/blob/a6bf6d55804850b390d840b87a679b784c0a3db4/actionpack/lib/action_dispatch/http/headers.rb#L5-L23
+          # in rack underscore and dashes resolve to the same header(using - instead of _)
+          key = key.gsub('_', '-')
+          ["#{attr_prefix}.#{key}".downcase, value]
+        end.to_h
+
+        attr_hash
+      end
+
+      def self.should_record_env?(env)
+        return false unless env.has_key?("CONTENT_TYPE")
+        Hypertrace::Instrumentation::DataCapture.can_capture?(env['CONTENT_TYPE'], Hypertrace::Instrumentation::DataCapture::TYPE_REQUEST)
+      end
+
+      def self.should_record_rack_array?(response)
+        content_type_arr = response[1].find{|x|x && x[0].downcase == "content-type"}
+        return false unless content_type_arr
+        content_type = content_type_arr[1]
+        Hypertrace::Instrumentation::DataCapture.can_capture?(content_type, Hypertrace::Instrumentation::DataCapture::TYPE_RESPONSE)
+      end
+
+      def self.extract_response_body rack_response
+        if rack_response.is_a?(Rack::BodyProxy)
+          Hypertrace::Instrumentation::DataCapture.capturable_body(rack_response.join(''))
+        elsif rack_response.is_a?(Array) && rack_response.length == 3
+          Hypertrace::Instrumentation::DataCapture.capturable_body(rack_response[2].join(''))
+        end
+      end
+
+      def self.extract_response_headers_as_attributes rack_response, attr_prefix
+        return unless Hypertrace::RubyAgent.instance.config.data_capture.http_headers.response
+        return if rack_response.is_a?(Rack::BodyProxy)
+
+        rack_response[1].map do |header, value|
+          ["#{attr_prefix}.#{header}".downcase, value]
+        end.to_h
+      end
+
+      def self.extract_headers_from_env env
+        result = env.select{|x|x.start_with?("HTTP_")}
+        result.transform_keys!{|k|k[5..-1]}
+        if env.has_key?("CONTENT_TYPE")
+          result['content-type'] = env['CONTENT_TYPE']
+        end
+        if env.has_key?("CONTENT_LENGTH")
+          result['content-length'] = env["CONTENT_LENGTH"]
+        end
+        result
+      end
+    end
+  end
+end