honeycomb-beeline 1.3.0 → 2.2.0

data/lib/honeycomb/integrations/aws.rb

@@ -106,8 +106,12 @@ module Honeycomb
           "aws.region" => context.config.region,
           "aws.service" => context.client.class.identifier,
           "aws.operation" => context.operation_name,
-          "aws.params" => context.params,
         }
+
+        context.params && context.params.each do |key, value|
+          context[:honeycomb_aws_sdk_data]["aws.params.#{key}"] = value
+        end
+
         span.add context[:honeycomb_aws_sdk_data]
       end
 

data/lib/honeycomb/integrations/faraday.rb

@@ -15,7 +15,7 @@ module Honeycomb
 
       @client.start_span(name: "http_client") do |span|
         span.add_field "request.method", env.method.upcase
-        span.add_field "request.protocol", env.url.scheme
+        span.add_field "request.scheme", env.url.scheme
         span.add_field "request.host", env.url.host
         span.add_field "request.path", env.url.path
         span.add_field "meta.type", "http_client"

data/lib/honeycomb/integrations/rack.rb

@@ -13,8 +13,14 @@ module Honeycomb
       ["HTTP_VERSION", "request.http_version"],
       ["HTTP_HOST", "request.host"],
       ["REMOTE_ADDR", "request.remote_addr"],
+      ["HTTP_X_FORWARDED_FOR", "request.header.x_forwarded_for"],
+      ["HTTP_X_FORWARDED_PROTO", "request.header.x_forwarded_proto"],
+      ["HTTP_X_FORWARDED_PORT", "request.header.x_forwarded_port"],
+      ["HTTP_ACCEPT", "request.header.accept"],
+      ["HTTP_ACCEPT_LANGUAGE", "request.header.accept_language"],
+      ["CONTENT_TYPE", "request.header.content_type"],
       ["HTTP_USER_AGENT", "request.header.user_agent"],
-      ["rack.url_scheme", "request.protocol"],
+      ["rack.url_scheme", "request.scheme"],
     ].freeze
 
     attr_reader :app, :client
@@ -25,16 +31,20 @@ module Honeycomb
     end
 
     def call(env)
+      req = ::Rack::Request.new(env)
       hny = env["HTTP_X_HONEYCOMB_TRACE"]
       client.start_span(name: "http_request", serialized_trace: hny) do |span|
         add_field = lambda do |key, value|
-          next unless value && !value.empty?
-
-          span.add_field(key, value)
+          unless value.nil? || (value.respond_to?(:empty?) && value.empty?)
+            span.add_field(key, value)
+          end
         end
 
         extract_fields(env, RACK_FIELDS, &add_field)
 
+        span.add_field("request.secure", req.ssl?)
+        span.add_field("request.xhr", req.xhr?)
+
         status, headers, body = app.call(env)
 
         add_package_information(env, &add_field)
@@ -42,6 +52,7 @@ module Honeycomb
         extract_user_information(env, &add_field)
 
         span.add_field("response.status_code", status)
+        span.add_field("response.content_type", headers["Content-Type"])
 
         [status, headers, body]
       end

data/lib/honeycomb/integrations/rails.rb

@@ -11,29 +11,79 @@ module Honeycomb
       yield "meta.package", "rails"
       yield "meta.package_version", ::Rails::VERSION::STRING
 
-      ::ActionDispatch::Request.new(env).tap do |request|
-        # calling request.params will blow up if raw_post is nil
-        # the only known cause of this is when using the
-        # [twirp](https://github.com/twitchtv/twirp-ruby) rack app mounted in
-        # the rails app
-        if request.raw_post
-          yield "request.controller", request.params[:controller]
-          yield "request.action", request.params[:action]
-        end
-
-        break unless request.respond_to? :routes
-        break unless request.routes.respond_to? :router
-
-        found_route = false
-        request.routes.router.recognize(request) do |route, _|
-          break if found_route
-
-          found_route = true
-          yield "request.route", "#{env['REQUEST_METHOD']} #{route.path.spec}"
-        end
+      request = ::ActionDispatch::Request.new(env)
+
+      yield "request.controller", request.path_parameters[:controller]
+      yield "request.action", request.path_parameters[:action]
+      yield "request.route", route_for(request)
+    end
+
+    private
+
+    def route_for(request)
+      router = router_for(request)
+      routing = routing_for(request)
+
+      return unless router && routing
+
+      router.recognize(routing) do |route, _|
+        return "#{request.method} #{route.path.spec}"
       end
     end
 
+    # Broadly compatible way of getting the ActionDispatch::Routing::RouteSet.
+    #
+    # While we'd like to just use ActionDispatch::Request#routes, that method
+    # was only added circa Rails 5. To support Rails 4, we have to use direct
+    # Rack env access.
+    #
+    # @see https://github.com/rails/rails/commit/87a75910640b83a677099198ccb3317d9850c204
+    def router_for(request)
+      routes = request.env["action_dispatch.routes"]
+      routes.router if routes.respond_to?(:router)
+    end
+
+    # Constructs a simplified ActionDispatch::Request with the original route.
+    #
+    # This is based on ActionDispatch::Routing::RouteSet#recognize_path, which
+    # reconstructs an ActionDispatch::Request using a given HTTP method + path
+    # by making a mock Rack environment. Here, instead of taking the method +
+    # path from input parameters, we use the original values from the actual
+    # incoming request (prior to any mangling that may have been done by
+    # middleware).
+    #
+    # The resulting ActionDispatch::Request instance is suitable for passing to
+    # ActionDispatch::Journey::Router#recognize to get the original Rails
+    # routing information corresponding to the incoming request.
+    #
+    # @param request [ActionDispatch::Request]
+    #   the actual incoming Rails request
+    #
+    # @return [ActionDispatch::Request]
+    #   a simplified version of the incoming request that retains the original
+    #   routing information, but nothing else (e.g., no HTTP parameters)
+    #
+    # @return [nil]
+    #   if the original request's path is invalid
+    #
+    # @see https://api.rubyonrails.org/classes/ActionDispatch/Request.html#method-i-method
+    # @see https://api.rubyonrails.org/classes/ActionDispatch/Request.html#method-i-original_fullpath
+    # @see https://github.com/rails/rails/blob/2a44ff12c858d296797963f7aa97abfa0c840a15/actionpack/lib/action_dispatch/journey/router/utils.rb#L7-L27
+    # @see https://github.com/rails/rails/blob/2a44ff12c858d296797963f7aa97abfa0c840a15/actionpack/lib/action_dispatch/routing/route_set.rb#L846-L859
+    def routing_for(request)
+      verb = request.method
+      path = request.original_fullpath
+      path = normalize(path) unless path =~ %r{://}
+      env = ::Rack::MockRequest.env_for(path, method: verb)
+      ::ActionDispatch::Request.new(env)
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def normalize(path)
+      ::ActionDispatch::Journey::Router::Utils.normalize_path(path)
+    end
+
     # Rails middleware
     class Middleware
       include Rack

data/lib/honeycomb/integrations/railtie.rb

@@ -9,9 +9,8 @@ module Honeycomb
     initializer("honeycomb.install_middleware",
                 after: :load_config_initializers) do |app|
       if Honeycomb.client
-        # what location should we insert the middleware at?
-        app.config.middleware.insert_before(
-          ::Rails::Rack::Logger,
+        app.config.middleware.insert_after(
+          ActionDispatch::ShowExceptions,
           Honeycomb::Rails::Middleware,
           client: Honeycomb.client,
         )

data/lib/honeycomb/integrations/redis.rb

@@ -23,7 +23,9 @@ module Honeycomb
       attr_writer :honeycomb_client
 
       def honeycomb_client
-        @honeycomb_client || Honeycomb.client
+        return @honeycomb_client if defined?(@honeycomb_client)
+
+        Honeycomb.client
       end
     end
 

data/lib/honeycomb/integrations/warden.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Honeycomb
-  # Methods for extracing common warden/devise fields from a rack env hash
+  # Methods for extracting common warden/devise fields from a rack env hash
   module Warden
     COMMON_USER_FIELDS = %i[
       email
@@ -24,7 +24,7 @@ module Honeycomb
         key.match(SCOPE_PATTERN)
       end
       warden_scopes = keys.map do |key|
-        key.gsub(SCOPE_PATTERN, "\1")
+        key.gsub(SCOPE_PATTERN, "\\1")
       end
       best_scope = warden_scopes.include?("user") ? "user" : warden_scopes.first
 

data/lib/honeycomb/propagation.rb

@@ -4,63 +4,16 @@ require "base64"
 require "json"
 require "uri"
 
+require "honeycomb/propagation/honeycomb"
+
 module Honeycomb
   # Parse trace headers
   module PropagationParser
-    def parse(serialized_trace)
-      unless serialized_trace.nil?
-        version, payload = serialized_trace.split(";", 2)
-
-        if version == "1"
-          trace_id, parent_span_id, trace_fields, dataset = parse_v1(payload)
-
-          if !trace_id.nil? && !parent_span_id.nil?
-            return [trace_id, parent_span_id, trace_fields, dataset]
-          end
-        end
-      end
-
-      [nil, nil, nil, nil]
-    end
-
-    def parse_v1(payload)
-      trace_id, parent_span_id, trace_fields, dataset = nil
-      payload.split(",").each do |entry|
-        key, value = entry.split("=", 2)
-        case key
-        when "dataset"
-          dataset = URI.decode_www_form_component(value)
-        when "trace_id"
-          trace_id = value
-        when "parent_id"
-          parent_span_id = value
-        when "context"
-          Base64.decode64(value).tap do |json|
-            begin
-              trace_fields = JSON.parse json
-            rescue JSON::ParserError
-              trace_fields = {}
-            end
-          end
-        end
-      end
-
-      [trace_id, parent_span_id, trace_fields, dataset]
-    end
+    include HoneycombPropagation::UnmarshalTraceContext
   end
 
   # Serialize trace headers
   module PropagationSerializer
-    def to_trace_header
-      context = Base64.urlsafe_encode64(JSON.generate(trace.fields)).strip
-      encoded_dataset = URI.encode_www_form_component(builder.dataset)
-      data_to_propogate = [
-        "dataset=#{encoded_dataset}",
-        "trace_id=#{trace.id}",
-        "parent_id=#{id}",
-        "context=#{context}",
-      ]
-      "1;#{data_to_propogate.join(',')}"
-    end
+    include HoneycombPropagation::MarshalTraceContext
   end
 end

data/lib/honeycomb/propagation/aws.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Honeycomb
+  # Parsing and propagation for AWS trace headers
+  module AWSPropagation
+    # Parse trace headers
+    module UnmarshalTraceContext
+      def parse(serialized_trace)
+        unless serialized_trace.nil?
+          split = serialized_trace.split(";")
+
+          trace_id, parent_span_id, trace_fields = get_fields(split)
+
+          parent_span_id = trace_id if parent_span_id.nil?
+
+          trace_fields = nil if trace_fields.empty?
+
+          if !trace_id.nil? && !parent_span_id.nil?
+            # return nil for dataset
+            return [trace_id, parent_span_id, trace_fields, nil]
+          end
+        end
+
+        [nil, nil, nil, nil]
+      end
+
+      def get_fields(fields)
+        trace_id, parent_span_id = nil
+        trace_fields = {}
+        fields.each do |entry|
+          key, value = entry.split("=", 2)
+          case key.downcase
+          when "root"
+            trace_id = value
+          when "self"
+            parent_span_id = value
+          when "parent"
+            parent_span_id = value if parent_span_id.nil?
+          else
+            trace_fields[key] = value unless key.empty?
+          end
+        end
+
+        [trace_id, parent_span_id, trace_fields]
+      end
+    end
+
+    # Serialize trace headers
+    module MarshalTraceContext
+      def to_trace_header
+        context = [""]
+        unless trace.fields.keys.nil?
+          trace.fields.keys.each do |key|
+            context.push("#{key}=#{trace.fields[key]}")
+          end
+        end
+
+        data_to_propagate = [
+          "Root=#{trace.id}",
+          "Parent=#{id}",
+        ]
+        "#{data_to_propagate.join(';')}#{context.join(';')}"
+      end
+    end
+  end
+end

data/lib/honeycomb/propagation/honeycomb.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "uri"
+
+module Honeycomb
+  # Parsing and propagation for honeycomb trace headers
+  module HoneycombPropagation
+    # Parse trace headers
+    module UnmarshalTraceContext
+      def parse(serialized_trace)
+        unless serialized_trace.nil?
+          version, payload = serialized_trace.split(";", 2)
+
+          if version == "1"
+            trace_id, parent_span_id, trace_fields, dataset = parse_v1(payload)
+
+            if !trace_id.nil? && !parent_span_id.nil?
+              return [trace_id, parent_span_id, trace_fields, dataset]
+            end
+          end
+        end
+
+        [nil, nil, nil, nil]
+      end
+
+      def parse_v1(payload)
+        trace_id, parent_span_id, trace_fields, dataset = nil
+        payload.split(",").each do |entry|
+          key, value = entry.split("=", 2)
+          case key.downcase
+          when "dataset"
+            dataset = URI.decode_www_form_component(value)
+          when "trace_id"
+            trace_id = value
+          when "parent_id"
+            parent_span_id = value
+          when "context"
+            Base64.decode64(value).tap do |json|
+              begin
+                trace_fields = JSON.parse json
+              rescue JSON::ParserError
+                trace_fields = {}
+              end
+            end
+          end
+        end
+
+        [trace_id, parent_span_id, trace_fields, dataset]
+      end
+    end
+
+    # Serialize trace headers
+    module MarshalTraceContext
+      def to_trace_header
+        context = Base64.urlsafe_encode64(JSON.generate(trace.fields)).strip
+        encoded_dataset = URI.encode_www_form_component(builder.dataset)
+        data_to_propogate = [
+          "dataset=#{encoded_dataset}",
+          "trace_id=#{trace.id}",
+          "parent_id=#{id}",
+          "context=#{context}",
+        ]
+        "1;#{data_to_propogate.join(',')}"
+      end
+    end
+  end
+end

data/lib/honeycomb/propagation/w3c.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Honeycomb
+  # Parsing and propagation for W3C trace headers
+  module W3CPropagation
+    # Parse trace headers
+    module UnmarshalTraceContext
+      INVALID_TRACE_ID = "00000000000000000000000000000000".freeze
+      INVALID_SPAN_ID = "0000000000000000".freeze
+
+      def parse(serialized_trace)
+        unless serialized_trace.nil?
+          version, payload = serialized_trace.split("-", 2)
+          # version should be 2 hex characters
+          if version =~ /^[A-Fa-f0-9]{2}$/
+            trace_id, parent_span_id = parse_v1(payload)
+
+            if !trace_id.nil? && !parent_span_id.nil?
+              # return nil for dataset
+              return [trace_id, parent_span_id, nil, nil]
+            end
+          end
+        end
+        [nil, nil, nil, nil]
+      end
+
+      def parse_v1(payload)
+        trace_id, parent_span_id, trace_flags = payload.split("-", 3)
+
+        if trace_flags.nil?
+          # if trace_flags is nil, it means a field is missing
+          return [nil, nil]
+        end
+
+        if trace_id == INVALID_TRACE_ID || parent_span_id == INVALID_SPAN_ID
+          return [nil, nil]
+        end
+
+        [trace_id, parent_span_id]
+      end
+    end
+
+    # Serialize trace headers
+    module MarshalTraceContext
+      def to_trace_header
+        # do not propagate malformed ids
+        if trace.id =~ /^[A-Fa-f0-9]{32}$/ && id =~ /^[A-Fa-f0-9]{16}$/
+          return "00-#{trace.id}-#{id}-01"
+        end
+
+        nil
+      end
+    end
+  end
+end