honeycomb-beeline 1.0.0.pre.alpha → 1.0.0.pre.alpha1

data/lib/honeycomb/integrations/active_support.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module Honeycomb
+  module ActiveSupport
+    ##
+    # Included in the configuration object to specify events that should be
+    # subscribed to
+    module Configuration
+      attr_accessor :notification_events
+
+      def after_initialize(client)
+        super(client) if defined?(super)
+
+        events = notification_events || []
+        ActiveSupport::Subscriber.new(client: client).tap do |sub|
+          events.each do |event|
+            sub.subscribe(event) do |span, payload|
+              payload.each do |key, value|
+                span.add_field("#{event}.#{key}", value.to_s)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Handles ActiveSupport::Notification subscriptions, relaying them to a
+    # Honeycomb client
+    class Subscriber
+      def initialize(client:)
+        @client = client
+        @handlers = {}
+        @key = ["honeycomb", self.class.name, object_id].join("-")
+      end
+
+      def subscribe(event, &block)
+        return unless block_given?
+
+        handlers[event] = block
+        ::ActiveSupport::Notifications.subscribe(event, self)
+      end
+
+      def start(name, id, _payload)
+        spans[id] << client.start_span(name: name)
+      end
+
+      def finish(name, id, payload)
+        return unless (span = spans[id].pop)
+
+        handlers[name].call(span, payload)
+
+        span.send
+      end
+
+      private
+
+      attr_reader :key, :client, :handlers
+
+      def spans
+        Thread.current[key] ||= Hash.new { |h, id| h[id] = [] }
+      end
+    end
+  end
+end
+
+Honeycomb::Configuration.include Honeycomb::ActiveSupport::Configuration

data/lib/honeycomb/integrations/faraday.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module Honeycomb
+  # Faraday middleware to create spans around outgoing http requests
+  class Faraday < ::Faraday::Middleware
+    def initialize(app, client:)
+      super(app)
+      @client = client
+    end
+
+    def call(env)
+      @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.host", env.url.host
+        span.add_field "request.path", env.url.path
+        span.add_field "meta.type", "http_client"
+        span.add_field "meta.package", "faraday"
+        span.add_field "meta.package_version", ::Faraday::VERSION
+
+        env.request_headers["X-Honeycomb-Trace"] = span.to_trace_header
+
+        @app.call(env).tap do |response|
+          span.add_field "response.status_code", response.status
+        end
+      end
+    end
+  end
+end
+
+::Faraday::Connection.module_eval do
+  alias_method :standard_initialize, :initialize
+
+  def initialize(url = nil, options = nil, &block)
+    standard_initialize(url, options, &block)
+
+    return if @builder.handlers.include? Honeycomb::Faraday
+
+    adapter_index = @builder.handlers.find_index do |handler|
+      handler.klass.ancestors.include? Faraday::Adapter
+    end
+
+    if adapter_index
+      @builder.insert_before(
+        adapter_index,
+        Honeycomb::Faraday,
+        client: Honeycomb.client,
+      )
+    else
+      @builder.use(Honeycomb::Faraday, client: Honeycomb.client)
+    end
+  end
+end
+
+Faraday::Middleware.register_middleware honeycomb: -> { Honeycomb::Faraday }

data/lib/honeycomb/integrations/rack.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module Honeycomb
+  # Automatically capture rack requests and create a trace
+  class Rack
+    RACK_FIELDS = [
+      ["REQUEST_METHOD", "request.method"],
+      ["PATH_INFO", "request.path"],
+      ["QUERY_STRING", "request.query_string"],
+      ["HTTP_VERSION", "request.http_version"],
+      ["HTTP_HOST", "request.host"],
+      ["REMOTE_ADDR", "request.remote_addr"],
+      ["HTTP_USER_AGENT", "request.header.user_agent"],
+      ["rack.url_scheme", "request.protocol"],
+    ].freeze
+
+    COMMON_USER_FIELDS = %i[
+      email
+      name
+      first_name
+      last_name
+      created_at
+      id
+    ].freeze
+
+    SCOPE_PATTERN = /^warden\.user\.([^.]+)\.key$/.freeze
+
+    attr_reader :app, :client
+
+    def initialize(app, client:)
+      @app = app
+      @client = client
+    end
+
+    def call(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)
+        end
+
+        extract_fields(env, RACK_FIELDS, &add_field)
+
+        status, headers, body = app.call(env)
+
+        add_package_information(env, &add_field)
+
+        extract_user_information(env, &add_field)
+
+        span.add_field("response.status_code", status)
+
+        [status, headers, body]
+      end
+    end
+
+    def add_package_information(_env)
+      yield "meta.package", "rack"
+      yield "meta.package_version", ::Rack::VERSION.join(".")
+    end
+
+    def extract_fields(env, fields)
+      fields.each do |key, value|
+        yield value, env[key]
+      end
+    end
+
+    def extract_user_information(env)
+      warden = env["warden"]
+
+      return unless warden
+
+      session = env["rack.session"] || {}
+      keys = session.keys.select do |key|
+        key.match(SCOPE_PATTERN)
+      end
+      warden_scopes = keys.map do |key|
+        key.gsub(SCOPE_PATTERN, "\1")
+      end
+      best_scope = warden_scopes.include?("user") ? "user" : warden_scopes.first
+
+      return unless best_scope
+
+      env["warden"].user(scope: best_scope, run_callbacks: false).tap do |user|
+        COMMON_USER_FIELDS.each do |field|
+          user.respond_to?(field) && yield("user.#{field}", user.send(field))
+        end
+      end
+    end
+  end
+end

data/lib/honeycomb/integrations/rails.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rails"
+require "honeycomb/integrations/active_support"
+require "honeycomb/integrations/rack"
+
+module Honeycomb
+  # Add Rails specific information to the Honeycomb::Rack middleware
+  module Rails
+    def add_package_information(env)
+      yield "meta.package", "rails"
+      yield "meta.package_version", ::Rails::VERSION::STRING
+
+      ::ActionDispatch::Request.new(env).tap do |request|
+        yield "request.controller", request.params[:controller]
+        yield "request.action", request.params[:action]
+
+        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
+      end
+    end
+  end
+
+  # Automatically capture rack requests and create a trace
+  class Railtie < ::Rails::Railtie
+    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,
+          Honeycomb::Rack,
+          client: Honeycomb.client,
+        )
+      end
+    end
+  end
+end
+
+Honeycomb::Rack.prepend Honeycomb::Rails

data/lib/honeycomb/integrations/sequel.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "sequel"
+
+module Honeycomb
+  # Wrap sequel commands in a span
+  module Sequel
+    def honeycomb_client
+      @honeycomb_client || Honeycomb.client
+    end
+
+    def honeycomb_client=(client)
+      @honeycomb_client = client
+    end
+
+    def log_connection_yield(sql, conn, args = nil)
+      return super if honeycomb_client.nil?
+
+      honeycomb_client.start_span(name: sql.sub(/\s+.*/, "").upcase) do |span|
+        span.add_field "meta.package", "sequel"
+        span.add_field "meta.package_version", ::Sequel::VERSION
+        span.add_field "type", "db"
+        span.add_field "db.sql", sql
+        super
+      end
+    end
+  end
+end
+
+Sequel::Database.register_extension(:honeycomb, Honeycomb::Sequel)
+Sequel::Database.extension :honeycomb

data/lib/honeycomb/integrations/sinatra.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "sinatra"
+require "honeycomb/integrations/rack"
+
+module Honeycomb
+  # Add Sinatra specific information to the Honeycomb::Rack middleware
+  module Sinatra
+    def add_package_information(env)
+      yield "meta.package", "sinatra"
+      yield "meta.package_version", ::Sinatra::VERSION
+
+      yield "request.route", env["sinatra.route"]
+    end
+  end
+end
+
+Honeycomb::Rack.prepend Honeycomb::Sinatra

data/lib/honeycomb/propagation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+
+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 = 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 PropagationSerializer
+    def to_trace_header
+      context = Base64.urlsafe_encode64(JSON.generate(trace.fields)).strip
+      "1;trace_id=#{trace.id},parent_id=#{id},context=#{context}"
+    end
+  end
+end

data/lib/honeycomb/span.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "honeycomb/propagation"
+
+module Honeycomb
+  # Represents a Honeycomb span, which wraps a Honeycomb event and adds specific
+  # tracing functionality
+  class Span
+    include PropagationSerializer
+    extend Forwardable
+
+    def_delegators :@event, :add_field, :add
+
+    attr_reader :id, :trace
+
+    def initialize(trace:,
+                   builder:,
+                   context:,
+                   parent_id: nil,
+                   is_root: parent_id.nil?)
+      @id = SecureRandom.uuid
+      @context = context
+      @context.current_span = self
+      @builder = builder
+      @event = builder.event
+      @trace = trace
+      @parent_id = parent_id
+      @is_root = is_root
+      @rollup_fields = Hash.new(0)
+      @children = []
+      @sent = false
+      @started = clock_time
+    end
+
+    def add_rollup_field(key, value)
+      trace.add_rollup_field(key, value)
+      rollup_fields[key] += value
+    end
+
+    def add_trace_field(key, value)
+      trace.add_field(key, value)
+    end
+
+    def create_child
+      self.class.new(trace: trace,
+                     builder: builder,
+                     context: context,
+                     parent_id: id).tap do |c|
+        children << c
+      end
+    end
+
+    def send
+      return if sent?
+
+      send_internal
+    end
+
+    protected
+
+    def send_by_parent
+      return if sent?
+
+      add_field "meta.sent_by_parent", true
+      send_internal
+    end
+
+    private
+
+    attr_reader :rollup_fields,
+                :event,
+                :parent_id,
+                :children,
+                :builder,
+                :context
+
+    def sent?
+      @sent
+    end
+
+    def root?
+      @is_root
+    end
+
+    def send_internal
+      add_field "duration_ms", duration_ms
+      add_field "trace.trace_id", trace.id
+      add_field "trace.span_id", id
+      add_field "meta.span_type", span_type
+      parent_id && add_field("trace.parent_id", parent_id)
+      add rollup_fields
+      add trace.fields
+      span_type == "root" && add(trace.rollup_fields)
+      send_children
+      event.send
+      @sent = true
+      context.span_sent(self)
+    end
+
+    def send_children
+      children.each do |child|
+        child.send_by_parent
+      end
+    end
+
+    def duration_ms
+      (clock_time - @started) * 1000
+    end
+
+    def clock_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def span_type
+      if root?
+        parent_id.nil? ? "root" : "subroot"
+      elsif children.empty?
+        "leaf"
+      else
+        "mid"
+      end
+    end
+  end
+end