honeycomb-beeline 2.1.2 → 2.4.2

data/README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://circleci.com/gh/honeycombio/beeline-ruby.svg?style=svg)](https://circleci.com/gh/honeycombio/beeline-ruby)
 [![Gem Version](https://badge.fury.io/rb/honeycomb-beeline.svg)](https://badge.fury.io/rb/honeycomb-beeline)
+[![codecov](https://codecov.io/gh/honeycombio/beeline-ruby/branch/main/graph/badge.svg)](https://codecov.io/gh/honeycombio/beeline-ruby)
 
 This package makes it easy to instrument your Ruby web app to send useful events to [Honeycomb](https://www.honeycomb.io), a service for debugging your software in production.
 - [Usage and Examples](https://docs.honeycomb.io/getting-data-in/beelines/ruby-beeline/)
@@ -24,6 +25,13 @@ Built in instrumentation for:
 - Sequel
 - Sinatra
 
+## Testing
+Find `rspec` test files in the `spec` directory.
+
+To run tests on gem-specific instrumentations or across various dependency versions, use [appraisal](https://github.com/thoughtbot/appraisal) (further instructions in the readme for that gem). Find gem sets in the `Appraisals` config.
+
+To run a specific file: `bundle exec appraisal <gem set> rspec <path/to/file>`
+
 ## Get in touch
 
 Please reach out to [support@honeycomb.io](mailto:support@honeycomb.io) or ping

data/UPGRADING.md

@@ -1,5 +1,15 @@
 # Upgrade Guide
 
+## 1.0.0 - 2.0.0
+
+1. See release notes: https://github.com/honeycombio/beeline-ruby/releases/tag/v2.0.0
+1. This update requires no code changes, but you must be aware of certain instrumentation changes. New fields will be added to your dataset and other fields will be removed.
+1. ActionController::Parameters will now result in extra fields, or nested json, depending on your unfurl settings.
+1. aws.params are now exploded into separate fields.
+1. request.error becomes error.
+1. request.error_detail becomes error_detail
+1. request.protocol becomes request.scheme
+
 ## 0.8.0 - 1.0.0
 
 1. If you have a web application, remove beeline configuration from the `config.ru` file

data/honeycomb-beeline.gemspec

@@ -42,11 +42,13 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "bump"
   spec.add_development_dependency "bundler"
+  spec.add_development_dependency "codecov"
   spec.add_development_dependency "overcommit", "~> 0.46.0"
   spec.add_development_dependency "pry", "< 0.13.0"
   spec.add_development_dependency "pry-byebug", "~> 3.6.0"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec_junit_formatter"
   spec.add_development_dependency "rubocop", "< 0.69"
   spec.add_development_dependency "rubocop-performance", "< 1.3.0"
   spec.add_development_dependency "simplecov"

data/lib/honeycomb-beeline.rb

@@ -26,7 +26,8 @@ module Honeycomb
     attr_reader :client
 
     def_delegators :@client, :libhoney, :start_span, :add_field,
-                   :add_field_to_trace, :current_span, :current_trace
+                   :add_field_to_trace, :current_span, :current_trace,
+                   :with_field, :with_trace_field
 
     def configure
       Configuration.new.tap do |config|

data/lib/honeycomb/beeline/version.rb

@@ -3,7 +3,7 @@
 module Honeycomb
   module Beeline
     NAME = "honeycomb-beeline".freeze
-    VERSION = "2.1.2".freeze
+    VERSION = "2.4.2".freeze
     USER_AGENT_SUFFIX = "#{NAME}/#{VERSION}".freeze
   end
 end

data/lib/honeycomb/client.rb

@@ -35,6 +35,8 @@ module Honeycomb
       @additional_trace_options = {
         presend_hook: configuration.presend_hook,
         sample_hook: configuration.sample_hook,
+        parser_hook: configuration.http_trace_parser_hook,
+        propagation_hook: configuration.http_trace_propagation_hook,
       }
 
       configuration.after_initialize(self)
@@ -87,6 +89,14 @@ module Honeycomb
       context.current_span.trace.add_field("app.#{key}", value)
     end
 
+    def with_field(key)
+      yield.tap { |value| add_field(key, value) }
+    end
+
+    def with_trace_field(key)
+      yield.tap { |value| add_field_to_trace(key, value) }
+    end
+
     private
 
     attr_reader :context

data/lib/honeycomb/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "socket"
+require "honeycomb/propagation/honeycomb"
 
 module Honeycomb
   # Used to configure the Honeycomb client
@@ -60,5 +61,27 @@ module Honeycomb
         @sample_hook
       end
     end
+
+    def http_trace_parser_hook(&hook)
+      if block_given?
+        @http_trace_parser_hook = hook
+      elsif @http_trace_parser_hook
+        @http_trace_parser_hook
+      else
+        # by default we try to parse incoming honeycomb traces
+        HoneycombPropagation::UnmarshalTraceContext.method(:parse_rack_env)
+      end
+    end
+
+    def http_trace_propagation_hook(&hook)
+      if block_given?
+        @http_trace_propagation_hook = hook
+      elsif @http_trace_propagation_hook
+        @http_trace_propagation_hook
+      else
+        # by default we send outgoing honeycomb trace headers
+        HoneycombPropagation::MarshalTraceContext.method(:parse_faraday_env)
+      end
+    end
   end
 end

data/lib/honeycomb/integrations/faraday.rb

@@ -22,7 +22,9 @@ module Honeycomb
         span.add_field "meta.package", "faraday"
         span.add_field "meta.package_version", ::Faraday::VERSION
 
-        env.request_headers["X-Honeycomb-Trace"] = span.to_trace_header
+        if (headers = span.trace_headers(env)).is_a?(Hash)
+          env.request_headers.merge!(headers)
+        end
 
         @app.call(env).tap do |response|
           span.add_field "response.status_code", response.status

data/lib/honeycomb/integrations/rack.rb

@@ -17,6 +17,7 @@ module Honeycomb
       ["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_ENCODING", "request.header.accept_encoding"],
       ["HTTP_ACCEPT_LANGUAGE", "request.header.accept_language"],
       ["CONTENT_TYPE", "request.header.content_type"],
       ["HTTP_USER_AGENT", "request.header.user_agent"],
@@ -32,8 +33,10 @@ module Honeycomb
 
     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|
+      client.start_span(
+        name: "http_request",
+        serialized_trace: env,
+      ) do |span|
         add_field = lambda do |key, value|
           unless value.nil? || (value.respond_to?(:empty?) && value.empty?)
             span.add_field(key, value)
@@ -45,11 +48,12 @@ module Honeycomb
         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)
-
-        extract_user_information(env, &add_field)
+        begin
+          status, headers, body = call_with_hook(env, span, &add_field)
+        ensure
+          add_package_information(env, &add_field)
+          extract_user_information(env, &add_field)
+        end
 
         span.add_field("response.status_code", status)
         span.add_field("response.content_type", headers["Content-Type"])
@@ -69,6 +73,12 @@ module Honeycomb
       end
     end
 
+    private
+
+    def call_with_hook(env, _span, &_add_field)
+      app.call(env)
+    end
+
     # Rack middleware
     class Middleware
       include Rack

data/lib/honeycomb/integrations/rails.rb

@@ -89,6 +89,16 @@ module Honeycomb
       include Rack
       include Warden
       include Rails
+
+      def call_with_hook(env, span, &_add_field)
+        super
+      rescue StandardError => e
+        wrapped = ActionDispatch::ExceptionWrapper.new(nil, e)
+
+        span.add_field "response.status_code", wrapped.status_code
+
+        raise e
+      end
     end
   end
 end

data/lib/honeycomb/integrations/redis.rb

@@ -159,7 +159,17 @@ module Honeycomb
       # * :logger - just some Ruby object, not useful
       # * :_parsed - implementation detail
       def ignore?(option)
-        %i[url password logger _parsed].include?(option)
+        # Redis options may be symbol or string keys.
+        #
+        # This normalizes `option` using `to_sym` as benchmarking on Ruby MRI
+        # v2.6.6 and v2.7.3 has shown that was faster compared to `to_s`.
+        # However, `nil` does not support `to_sym`. This uses a guard clause to
+        # handle the `nil` case because this is still faster than safe
+        # navigation. Also this lib still supports Ruby 2.2.0; which does not
+        # include safe navigation.
+        return true unless option
+
+        %i[url password logger _parsed].include?(option.to_sym)
       end
 
       def format(cmd)
@@ -177,16 +187,6 @@ module Honeycomb
         args.map! { "[sanitized]" }
       end
 
-      def prettify(arg)
-        quotes = false
-        pretty = "".dup
-        arg.to_s.each_char do |c|
-          quotes ||= needs_quotes?(c)
-          pretty << escape(c)
-        end
-        quotes ? "\"#{pretty}\"" : pretty
-      end
-
       # This aims to replicate the algorithms used by redis-cli.
       #
       # @see https://github.com/antirez/redis/blob/0f026af185e918a9773148f6ceaa1b084662be88/src/sds.c#L940-L1067
@@ -194,54 +194,15 @@ module Honeycomb
       #
       # @see https://github.com/antirez/redis/blob/0f026af185e918a9773148f6ceaa1b084662be88/src/sds.c#L878-L907
       #   The redis-cli printing algorithm
-      def escape(char)
-        return escape_with_backslash(char) if escape_with_backslash?(char)
-        return escape_with_hex_codes(char) if escape_with_hex_codes?(char)
-
-        char
-      end
-
-      # A lookup table for backslash-escaped characters.
-      #
-      # This is used by {#escape_with_backslash?} and {#escape_with_backslash}
-      # to replicate the hard-coded `case` statements in redis-cli. As of this
-      # writing, Redis recognizes a handful of standard C escape sequences,
-      # like "\n" for newlines.
-      #
-      # Because {#prettify} will output double quoted strings if any escaping
-      # is needed, this table must additionally consider the double-quote to be
-      # a backslash-escaped character. For example, instead of generating
-      #
-      #   '"hello"'
-      #
-      # we'll generate
-      #
-      #   "\"hello\""
-      #
-      # even though redis-cli would technically recognize the single-quoted
-      # version.
-      #
-      # @see https://github.com/antirez/redis/blob/0f026af185e918a9773148f6ceaa1b084662be88/src/sds.c#L888-L896
-      #   The redis-cli algorithm for outputting standard escape sequences
-      BACKSLASHES = {
-        "\\" => "\\\\",
-        '"' => '\\"',
-        "\n" => "\\n",
-        "\r" => "\\r",
-        "\t" => "\\t",
-        "\a" => "\\a",
-        "\b" => "\\b",
-      }.freeze
-
-      def escape_with_backslash?(char)
-        BACKSLASHES.key?(char)
-      end
-
-      def escape_with_backslash(char)
-        BACKSLASHES.fetch(char, char)
+      def prettify(arg)
+        pretty = arg.to_s.dup
+        pretty.encode!("UTF-8", "binary", fallback: ->(c) { hex(c) })
+        pretty.gsub!(NEEDS_BACKSLASH, BACKSLASH)
+        pretty.gsub!(NEEDS_HEX) { |c| hex(c) }
+        pretty =~ NEEDS_QUOTES ? "\"#{pretty}\"" : pretty
       end
 
-      # Do we need to hex-encode this character?
+      # A regular expression matching characters that need to be hex-encoded.
       #
       # This replicates the C isprint() function that redis-cli uses to decide
       # whether to escape a character in hexadecimal notation, "\xhh". Any
@@ -277,18 +238,95 @@ module Honeycomb
       # escape it.
       #
       # What's more, Ruby's Regexp#=~ method will blow up if the string does
-      # not have a valid encoding (e.g., in UTF-8). In this case, though,
-      # {#escape_with_hex_codes} can still convert the bytes that make up the
-      # invalid character into a hex code. So we preemptively check for
-      # invalidly-encoded characters before testing the above match.
+      # not have a valid encoding (e.g., in UTF-8). We handle this case
+      # separately, though, using String#encode! with a :fallback option to
+      # hex-encode invalid UTF-8 byte sequences with {#hex}.
       #
       # @see https://ruby-doc.org/core-2.6.5/Regexp.html
       # @see https://github.com/antirez/redis/blob/0f026af185e918a9773148f6ceaa1b084662be88/src/sds.c#L878-L880
       # @see https://github.com/antirez/redis/blob/0f026af185e918a9773148f6ceaa1b084662be88/src/sds.c#L898-L901
       # @see https://www.justinweiss.com/articles/3-steps-to-fix-encoding-problems-in-ruby/
-      def escape_with_hex_codes?(char)
-        !char.valid_encoding? || char =~ /[^[:print:]&&[:ascii:]]/
-      end
+      NEEDS_HEX = /[^[:print:]&&[:ascii:]]/.freeze
+
+      # A regular expression for characters that need to be backslash-escaped.
+      #
+      # Any match of this regexp will be substituted according to the
+      # {BACKSLASH} table. This includes standard C escape sequences (newlines,
+      # tabs, etc) as well as a couple special considerations:
+      #
+      # 1. Because {#prettify} will output double quoted strings if any
+      #    escaping is needed, we must match double quotes (") so they'll be
+      #    replaced by escaped quotes (\").
+      #
+      # 2. Backslashes themselves get backslash-escaped, so \ becomes \\.
+      #    However, strings with invalid UTF-8 encoding will blow up when we
+      #    try to use String#gsub!, so {#prettify} must first use
+      #    String#encode! to scrub out invalid characters. It does this by
+      #    replacing invalid bytes with hex-encoded escape sequences using
+      #    {#hex}. This will insert sequences like \xhh, which contains a
+      #    backslash that we *don't* want to escape.
+      #
+      #    Unfortunately, this regexp can't really distinguish between
+      #    backslashes in the original input vs backslashes resulting from the
+      #    UTF-8 fallback. We make an effort by using a negative lookahead.
+      #    That way, only backslashes that *aren't* followed by x + hex digit +
+      #    hex digit will be escaped.
+      NEEDS_BACKSLASH = /["\n\r\t\a\b]|\\(?!x\h\h)/.freeze
+
+      # A lookup table for backslash-escaped characters.
+      #
+      # This is used by {#prettify} to replicate the hard-coded `case`
+      # statements in redis-cli. As of this writing, Redis recognizes a handful
+      # of standard C escape sequences, like "\n" for newlines.
+      #
+      # Because {#prettify} will output double quoted strings if any escaping
+      # is needed, this table must additionally consider the double-quote to be
+      # a backslash-escaped character. For example, instead of generating
+      #
+      #   '"hello"'
+      #
+      # we'll generate
+      #
+      #   "\"hello\""
+      #
+      # even though redis-cli would technically recognize the single-quoted
+      # version.
+      #
+      # @see https://github.com/antirez/redis/blob/0f026af185e918a9773148f6ceaa1b084662be88/src/sds.c#L888-L896
+      #   The redis-cli algorithm for outputting standard escape sequences
+      BACKSLASH = {
+        "\\" => "\\\\",
+        '"' => '\\"',
+        "\n" => "\\n",
+        "\r" => "\\r",
+        "\t" => "\\t",
+        "\a" => "\\a",
+        "\b" => "\\b",
+      }.freeze
+
+      # If the final escaped string needs quotes, it will match this regexp.
+      #
+      # The overall string returned by {#prettify} should only be quoted if at
+      # least one of the following holds:
+      #
+      # 1. The string contains an escape sequence, broadly demarcated by a
+      #    backslash. This includes standard escape sequences like "\n" and
+      #    "\t" as well as hex-encoded bytes using the "\x" escape sequence.
+      #    Since {#prettify} uses double quotes on its output string, we must
+      #    also force quotes if the string itself contains a literal
+      #    double quote. This double quote behavior is handled tacitly by the
+      #    {NEEDS_BACKSLASH} + {BACKSLASH} replacement.
+      #
+      # 2. The string contains a single quote. Since redis-cli recognizes
+      #    single-quoted strings, we want to wrap the {#prettify} output in
+      #    double quotes so that the literal single quote character isn't
+      #    mistaken as the delimiter of a new string.
+      #
+      # 3. The string contains any whitespace characters. If the {#prettify}
+      #    output weren't wrapped in quotes, whitespace would act as a
+      #    separator between arguments to the Redis command. To group things
+      #    together, we need to quote the string.
+      NEEDS_QUOTES = /[\\'\s]/.freeze
 
       # Hex-encodes a (presumably non-printable or non-ASCII) character.
       #
@@ -316,38 +354,9 @@ module Honeycomb
       # @see https://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap07.html
       # @see https://github.com/antirez/redis/blob/0f026af185e918a9773148f6ceaa1b084662be88/src/sds.c#L878-L880
       # @see https://github.com/antirez/redis/blob/0f026af185e918a9773148f6ceaa1b084662be88/src/sds.c#L898-L901
-      def escape_with_hex_codes(char)
+      def hex(char)
         char.bytes.map { |b| Kernel.format("\\x%02x", b) }.join
       end
-
-      def escape?(char)
-        escape_with_backslash?(char) || escape_with_hex_codes?(char)
-      end
-
-      # Should this character cause {#prettify} to wrap its output in quotes?
-      #
-      # The overall string returned by {#prettify} should only be quoted if at
-      # least one of the following holds:
-      #
-      # 1. The string contains a character that needs to be escaped. This
-      #    includes standard backslash escape sequences (like "\n" and "\t") as
-      #    well as hex-encoded bytes using the "\x" escape sequence. Since
-      #    {#prettify} uses double quotes on its output string, we must also
-      #    force quotes if the string itself contains a literal double quote.
-      #    This double quote behavior is handled tacitly by {BACKSLASHES}.
-      #
-      # 2. The string contains a single quote. Since redis-cli recognizes
-      #    single-quoted strings, we want to wrap the {#prettify} output in
-      #    double quotes so that the literal single quote character isn't
-      #    mistaken as the delimiter of a new string.
-      #
-      # 3. The string contains any whitespace characters. If the {#prettify}
-      #    output weren't wrapped in quotes, whitespace would act as a
-      #    separator between arguments to the Redis command. To group things
-      #    together, we need to quote the string.
-      def needs_quotes?(char)
-        escape?(char) || char == "'" || char =~ /\s/
-      end
     end
   end
 end