honeybadger 5.4.0 → 5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5847b4e0178589581a37418fd55ae92ac70411f4f6ca5e00ddb93249075783f1
-  data.tar.gz: 4211b04bf7b3db5c953d1a8bdafacb758900d9cdf8767d29d4c9145012daef69
+  metadata.gz: cb3f1cce4a9922e40fb7f08e37ccaa3f826aabd9d529b13a49fec50ba22990b0
+  data.tar.gz: 024676b627053cb84cec4bffbae7f35718d7dc38e81937a50fc4435c936a4301
 SHA512:
-  metadata.gz: e3859b35643ca918fd3dec7eb0894e776ee5aee9246de412a6c1da26f32f42eee24b0b156ebccef37eddeb10a0e82f2ffd6d4c01d8a35e77ef1f13f9269cc83d
-  data.tar.gz: ce7ab35a627c82d3b43d7362de4386f29368ea8fe29a9009a9c3f8089a097c24ea0b0f23765a40b5dc1e2721a059e79db6ac930eb6f80cc4afe18c5568bc9f67
+  metadata.gz: 569ba0e6b76df2349b10a8d37417b13be728cb7abdc6aaec958fa76ed2d912498624758f1c18f085f9e003611832d81937a6427a4bbcd2f51f3532fa4fffe550
+  data.tar.gz: c5eb3f07437df88834e8ca6c35327f0af3cf1cf93b94cf8809212313ffa316d071c4ee32cdf4ef5ea89e98164cb01024992e086fd47386a1ad4b3a5fe9318bf5

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change Log
 
+## [5.5.0](https://github.com/honeybadger-io/honeybadger-ruby/compare/v5.4.1...v5.5.0) (2024-02-12)
+
+
+### Features
+
+* implements honeybadger.event by synchronous log call ([#512](https://github.com/honeybadger-io/honeybadger-ruby/issues/512)) ([dbe7e3d](https://github.com/honeybadger-io/honeybadger-ruby/commit/dbe7e3dc20cbb432254b055b356826a42a76c609))
+
+## [5.4.1](https://github.com/honeybadger-io/honeybadger-ruby/compare/v5.4.0...v5.4.1) (2023-12-22)
+
+
+### Bug Fixes
+
+* ignore vendor/bundle when creating gem ([#515](https://github.com/honeybadger-io/honeybadger-ruby/issues/515)) ([a38658f](https://github.com/honeybadger-io/honeybadger-ruby/commit/a38658f84f5ecc062fce7b606311107483f7af96)), closes [#514](https://github.com/honeybadger-io/honeybadger-ruby/issues/514)
+
 ## [5.4.0](https://github.com/honeybadger-io/honeybadger-ruby/compare/v5.3.0...v5.4.0) (2023-12-04)
 
 

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Honeybadger Industries LLC
+Copyright (c) 2024 Honeybadger Industries LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/honeybadger/agent.rb

@@ -7,6 +7,7 @@ require 'honeybadger/notice'
 require 'honeybadger/plugin'
 require 'honeybadger/logging'
 require 'honeybadger/worker'
+require 'honeybadger/events_worker'
 require 'honeybadger/breadcrumbs'
 
 module Honeybadger
@@ -354,6 +355,7 @@ module Honeybadger
       yield
     ensure
       worker.flush
+      events_worker&.flush
     end
 
     # Stops the Honeybadger service.
@@ -362,9 +364,41 @@ module Honeybadger
     #   Honeybadger.stop # => nil
     def stop(force = false)
       worker.shutdown(force)
+      events_worker&.shutdown(force)
       true
     end
 
+    # Sends event to events backend
+    #
+    # @example
+    #   # With event type as first argument (recommended):
+    #   Honeybadger.event("user_signed_up", user_id: 123)
+    #
+    #   # With just a payload:
+    #   Honeybadger.event(event_type: "user_signed_up", user_id: 123)
+    #
+    # @param event_name [String, Hash] a String describing the event or a Hash
+    #   when the second argument is omitted.
+    # @param payload [Hash] Additional data to be sent with the event as keyword arguments
+    #
+    # @return [void]
+    def event(event_type, payload = {})
+      init_events_worker
+
+      ts = DateTime.now.new_offset(0).rfc3339
+      merged = {ts: ts}
+
+      if event_type.is_a?(String)
+        merged.merge!(event_type: event_type)
+      else
+        merged.merge!(Hash(event_type))
+      end
+
+      merged.merge!(Hash(payload))
+
+      events_worker.push(merged)
+    end
+
     # @api private
     attr_reader :config
 
@@ -437,7 +471,7 @@ module Honeybadger
     end
 
     # @api private
-    attr_reader :worker
+    attr_reader :worker, :events_worker
 
     # @api private
     # @!method init!(...)
@@ -475,9 +509,15 @@ module Honeybadger
     end
 
     def init_worker
+      return if @worker
       @worker = Worker.new(config)
     end
 
+    def init_events_worker
+      return if @events_worker
+      @events_worker = EventsWorker.new(config)
+    end
+
     def with_error_handling
       yield
     rescue => ex

data/lib/honeybadger/backend/base.rb

@@ -109,6 +109,16 @@ module Honeybadger
         notify(:deploys, payload)
       end
 
+      # Send event
+      # @example
+      #   backend.event([{event_type: "email_received", ts: "2023-03-04T12:12:00+1:00", subject: 'Re: Aquisition' }})
+      #
+      # @param [Array] payload array of event hashes to send
+      # @raise NotImplementedError
+      def event(payload)
+        raise NotImplementedError, "must define #event on subclass"
+      end
+
       private
 
       attr_reader :config

data/lib/honeybadger/backend/debug.rb

@@ -17,6 +17,12 @@ module Honeybadger
         return Response.new(ENV['DEBUG_BACKEND_STATUS'].to_i, nil) if ENV['DEBUG_BACKEND_STATUS']
         super
       end
+
+      def event(payload)
+        logger.unknown("sending event to debug backend with event=#{payload.to_json}")
+        return Response.new(ENV['DEBUG_BACKEND_STATUS'].to_i, nil) if ENV['DEBUG_BACKEND_STATUS']
+        super
+      end
     end
   end
 end

data/lib/honeybadger/backend/null.rb

@@ -24,6 +24,10 @@ module Honeybadger
       def check_in(id)
         StubbedResponse.new
       end
+
+      def event(payload)
+        StubbedResponse.new
+      end
     end
   end
 end

data/lib/honeybadger/backend/server.rb

@@ -11,11 +11,10 @@ module Honeybadger
     class Server < Base
       ENDPOINTS = {
         notices: '/v1/notices'.freeze,
-        deploys: '/v1/deploys'.freeze
+        deploys: '/v1/deploys'.freeze,
       }.freeze
-
       CHECK_IN_ENDPOINT = '/v1/check_in'.freeze
-
+      EVENTS_ENDPOINT = '/v1/events'.freeze
 
       HTTP_ERRORS = Util::HTTP::ERRORS
 
@@ -48,6 +47,18 @@ module Honeybadger
         Response.new(:error, nil, "HTTP Error: #{e.class}")
       end
 
+      # Send event
+      # @example
+      #   backend.event([{event_type: "email_received", ts: "2023-03-04T12:12:00+1:00", subject: 'Re: Aquisition' }})
+      #
+      # @param [Array] payload array of event hashes to send
+      # @return [Response]
+      def event(payload)
+        Response.new(@http.post_newline_delimited(EVENTS_ENDPOINT, payload))
+      rescue *HTTP_ERRORS => e
+        Response.new(:error, nil, "HTTP Error: #{e.class}")
+      end
+
       private
 
       def payload_headers(payload)

data/lib/honeybadger/config/defaults.rb

@@ -91,6 +91,16 @@ module Honeybadger
         default: 100,
         type: Integer
       },
+      :'events.batch_size' => {
+        description: 'Send events batch if n events have accumulated',
+        default: 100,
+        type: Integer
+      },
+      :'events.timeout' => {
+        description: 'Timeout after which the events batch will be sent regardless (in milliseconds)',
+        default: 30_000,
+        type: Integer
+      },
       plugins: {
         description: 'An optional list of plugins to load. Default is to load all plugins.',
         default: nil,

data/lib/honeybadger/config.rb

@@ -224,6 +224,14 @@ module Honeybadger
       self[:max_queue_size]
     end
 
+    def events_batch_size
+      self[:'events.batch_size']
+    end
+
+    def events_timeout
+      self[:'events.timeout']
+    end
+
     def params_filters
       Array(self[:'request.filter_keys'])
     end

data/lib/honeybadger/events_worker.rb

@@ -0,0 +1,319 @@
+require 'forwardable'
+require 'net/http'
+
+require 'honeybadger/logging'
+
+module Honeybadger
+  # A concurrent queue to notify the backend.
+  # @api private
+  class EventsWorker
+    extend Forwardable
+
+    include Honeybadger::Logging::Helper
+
+    # Sub-class thread so we have a named thread (useful for debugging in Thread.list).
+    class Thread < ::Thread; end
+
+    # Used to signal the worker to shutdown.
+    SHUTDOWN = :__hb_worker_shutdown!
+    FLUSH = :__hb_worker_flush!
+    CHECK_TIMEOUT = :__hb_worker_check_timeout!
+
+    # The base number for the exponential backoff formula when calculating the
+    # throttle interval. `1.05 ** throttle` will reach an interval of 2 minutes
+    # after around 100 429 responses from the server.
+    BASE_THROTTLE = 1.05
+
+    # TODO: These could be configurable?
+
+    def initialize(config)
+      @config = config
+      @throttle = 0
+      @throttle_interval = 0
+      @mutex = Mutex.new
+      @marker = ConditionVariable.new
+      @queue = Queue.new
+      @send_queue = Queue.new
+      @shutdown = false
+      @start_at = nil
+      @pid = Process.pid
+      @send_queue = []
+      @last_sent = nil
+    end
+
+    def push(msg)
+      return false unless start
+
+      if queue.size >= config.max_queue_size
+        warn { sprintf('Unable to send event; reached max queue size of %s.', queue.size) }
+        return false
+      end
+
+      queue.push(msg)
+    end
+
+    def send_now(msg)
+      handle_response(send_to_backend(msg))
+    end
+
+    def shutdown(force = false)
+      d { 'shutting down events worker' }
+
+      mutex.synchronize do
+        @shutdown = true
+      end
+
+      return true if force
+      return true unless thread&.alive?
+
+      if throttled?
+        warn { sprintf('Unable to send %s event(s) to Honeybadger (currently throttled)', queue.size) } unless queue.empty?
+        return true
+      end
+
+      info { sprintf('Waiting to send %s events(s) to Honeybadger', queue.size) } unless queue.empty?
+      queue.push(FLUSH)
+      queue.push(SHUTDOWN)
+      !!thread.join
+    ensure
+      queue.clear
+      kill!
+    end
+
+    # Blocks until queue is processed up to this point in time.
+    def flush
+      mutex.synchronize do
+        if thread && thread.alive?
+          queue.push(FLUSH)
+          queue.push(marker)
+          marker.wait(mutex)
+        end
+      end
+    end
+
+    def start
+      return false unless can_start?
+
+      mutex.synchronize do
+        @shutdown = false
+        @start_at = nil
+
+        return true if thread&.alive?
+
+        @pid = Process.pid
+        @thread = Thread.new { run }
+        @timeout_thread = Thread.new { schedule_timeout_check }
+      end
+
+      true
+    end
+
+    private
+
+    attr_reader :config, :queue, :pid, :mutex, :marker, :thread, :timeout_thread, :throttle,
+      :throttle_interval, :start_at, :send_queue, :last_sent
+
+    def_delegator :config, :backend
+
+    def shutdown?
+      mutex.synchronize { @shutdown }
+    end
+
+    def suspended?
+      mutex.synchronize { start_at && Time.now.to_i < start_at }
+    end
+
+    def can_start?
+      return false if shutdown?
+      return false if suspended?
+      true
+    end
+
+    def throttled?
+      mutex.synchronize { throttle > 0 }
+    end
+
+    def kill!
+      d { 'killing worker thread' }
+
+      if thread
+        Thread.kill(thread)
+        Thread.kill(timeout_thread)
+        thread.join # Allow ensure blocks to execute.
+      end
+
+      true
+    end
+
+    def suspend(interval)
+      mutex.synchronize do
+        @start_at = Time.now.to_i + interval
+        queue.clear
+      end
+
+      # Must be performed last since this may kill the current thread.
+      kill!
+    end
+
+    def schedule_timeout_check
+      loop do
+        sleep(config.events_timeout / 1000.0)
+        queue.push(CHECK_TIMEOUT)
+      end
+    end
+
+    def run
+      begin
+        d { 'worker started' }
+        mutex.synchronize do
+          @last_sent = Time.now
+        end
+        loop do
+          case msg = queue.pop
+          when SHUTDOWN then break
+          when CHECK_TIMEOUT then check_timeout
+          when FLUSH then flush_send_queue
+          when ConditionVariable then signal_marker(msg)
+          else work(msg)
+          end
+        end
+      ensure
+        d { 'stopping worker' }
+      end
+    rescue Exception => e
+      error {
+        msg = "Error in worker thread (shutting down) class=%s message=%s\n\t%s"
+        sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+      }
+    ensure
+      release_marker
+    end
+
+    def check_timeout
+      return if mutex.synchronize { send_queue.empty? }
+      ms_since = (Time.now.to_f - last_sent.to_f) * 1000.0
+      if ms_since >= config.events_timeout
+        send_batch
+      end
+    end
+
+    def enqueue_msg(msg)
+      mutex.synchronize do
+        @send_queue << msg
+      end
+    end
+
+    def send_batch
+      send_now(mutex.synchronize { send_queue })
+      mutex.synchronize do
+        @last_sent = Time.now
+        send_queue.clear
+      end
+    end
+
+    def check_and_send
+      return if mutex.synchronize { send_queue.empty? }
+      if mutex.synchronize { send_queue.length } >= config.events_batch_size
+        send_batch
+      end
+    end
+
+    def flush_send_queue
+      return if mutex.synchronize { send_queue.empty? }
+      send_batch
+    rescue StandardError => e
+      error {
+        msg = "Error in worker thread class=%s message=%s\n\t%s"
+        sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+      }
+    end
+
+    def work(msg)
+      enqueue_msg(msg)
+      check_and_send
+
+      if shutdown? && throttled?
+        warn { sprintf('Unable to send %s events(s) to Honeybadger (currently throttled)', queue.size) } if queue.size > 1
+        kill!
+        return
+      end
+
+      sleep(throttle_interval)
+    rescue StandardError => e
+      error {
+        msg = "Error in worker thread class=%s message=%s\n\t%s"
+        sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+      }
+    end
+
+
+    def send_to_backend(msg)
+      d { 'events_worker sending to backend' }
+      response = backend.event(msg)
+      response
+    end
+
+    def calc_throttle_interval
+      ((BASE_THROTTLE ** throttle) - 1).round(3)
+    end
+
+    def inc_throttle
+      mutex.synchronize do
+        @throttle += 1
+        @throttle_interval = calc_throttle_interval
+        throttle
+      end
+    end
+
+    def dec_throttle
+      mutex.synchronize do
+        return nil if throttle == 0
+        @throttle -= 1
+        @throttle_interval = calc_throttle_interval
+        throttle
+      end
+    end
+
+    def handle_response(response)
+      d { sprintf('events_worker response code=%s message=%s', response.code, response.message.to_s.dump) }
+
+      case response.code
+      when 429, 503
+        throttle = inc_throttle
+        warn { sprintf('Event send failed: project is sending too many events. code=%s throttle=%s interval=%s', response.code, throttle, throttle_interval) }
+      when 402
+        warn { sprintf('Event send failed: payment is required. code=%s', response.code) }
+        suspend(3600)
+      when 403
+        warn { sprintf('Event send failed: API key is invalid. code=%s', response.code) }
+        suspend(3600)
+      when 413
+        warn { sprintf('Event send failed: Payload is too large. code=%s', response.code) }
+      when 201
+        if throttle = dec_throttle
+          info { sprintf('Success ⚡ Event sent code=%s throttle=%s interval=%s', response.code, throttle, throttle_interval) }
+        else
+          info { sprintf('Success ⚡ Event sent code=%s', response.code) }
+        end
+      when :stubbed
+        info { sprintf('Success ⚡ Development mode is enabled; This event will be sent after app is deployed.') }
+      when :error
+        warn { sprintf('Event send failed: an unknown error occurred. code=%s error=%s', response.code, response.message.to_s.dump) }
+      else
+        warn { sprintf('Event send failed: unknown response from server. code=%s', response.code) }
+      end
+    end
+
+    # Release the marker. Important to perform during cleanup when shutting
+    # down, otherwise it could end up waiting indefinitely.
+    def release_marker
+      signal_marker(marker)
+    end
+
+    def signal_marker(marker)
+      mutex.synchronize do
+        marker.signal
+      end
+    end
+  end
+end

data/lib/honeybadger/singleton.rb

@@ -38,6 +38,7 @@ module Honeybadger
   def_delegator :'Honeybadger::Agent.instance', :breadcrumbs
   def_delegator :'Honeybadger::Agent.instance', :clear!
   def_delegator :'Honeybadger::Agent.instance', :track_deployment
+  def_delegator :'Honeybadger::Agent.instance', :event
 
   # @!macro [attach] def_delegator
   #   @!method $2(...)

data/lib/honeybadger/util/http.rb

@@ -49,6 +49,12 @@ module Honeybadger
         response
       end
 
+      def post_newline_delimited(endpoint, payload, headers = nil)
+        response = http_connection.post(endpoint, compress(payload.map(&:to_json).join("\n")), http_headers(headers))
+        debug { sprintf("http method=POST path=%s code=%d", endpoint.dump, response.code) }
+        response
+      end
+
       private
 
       attr_reader :config

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # The current String Honeybadger version.
-  VERSION = '5.4.0'.freeze
+  VERSION = '5.5.0'.freeze
 end