forge_ops_tracker 0.2.1 → 0.7.0

data/lib/forge_ops_tracker/railtie.rb

@@ -2,6 +2,20 @@ require "rails/railtie"
 
 module ForgeOpsTracker
   class Railtie < ::Rails::Railtie
+    # Shared across every performance-timing subscription/integration below (controller, query,
+    # job, raw Sidekiq, outbound Net::HTTP): one flusher, one background thread, one set of
+    # buckets, since PerformanceFlusher already buckets on [transaction_name, kind] and safely
+    # handles concurrent calls from several sources at once. Exposed as a class method, not a
+    # local variable inside one initializer, specifically so the Sidekiq/Net::HTTP integrations
+    # (each guarded by their own separate initializer, since each only loads if its own optional
+    # library is present) can record into the exact same instance rather than each starting a
+    # redundant flusher/thread of their own.
+    class << self
+      def performance_flusher
+        @performance_flusher ||= ForgeOpsTracker::PerformanceFlusher.new(ForgeOpsTracker.configuration)
+      end
+    end
+
     initializer "forge_ops_tracker.subscribe_error_reporter" do |app|
       configuration = ForgeOpsTracker.configuration
       configuration.app_root ||= app.root.to_s
@@ -10,5 +24,114 @@ module ForgeOpsTracker
 
       Rails.error.subscribe(ForgeOpsTracker::ErrorSubscriber.new(configuration))
     end
+
+    initializer "forge_ops_tracker.track_sessions" do |app|
+      app.middleware.use ForgeOpsTracker::Middleware::SessionTracking, configuration: ForgeOpsTracker.configuration
+    end
+
+    # Warden::Manager (mounted automatically by Devise, or directly by any other Warden-based
+    # auth setup) sets env["warden"] itself; this only ever reads it, so it works regardless of
+    # exactly where in the middleware stack this ends up relative to Warden::Manager, as long as
+    # that key exists in env by the time this middleware's own #call runs, which is true for any
+    # Warden-based auth setup: it mounts its own middleware once, for the whole app, long before
+    # any individual request begins.
+    initializer "forge_ops_tracker.track_current_user" do |app|
+      app.middleware.use ForgeOpsTracker::Middleware::UserContext, configuration: ForgeOpsTracker.configuration
+    end
+
+    # Rails already fires "process_action.action_controller" after every request with the
+    # controller/action and how long it took (event.duration, in ms) built in, so unlike session
+    # tracking above (which needed a Rack middleware because there's no single existing hook for
+    # "a request finished"), this needs no middleware of its own at all, just a subscriber.
+    # Guarded the same way the error subscriber and session-tracking middleware both are: on by
+    # default, off entirely if track_performance is turned off or the gem itself isn't enabled
+    # (no DSN configured, or the current environment isn't in enabled_environments).
+    #
+    # sql.active_record/perform.active_job are subscribed here too, not in their own separate
+    # initializers: all three (plus Sidekiq/Net::HTTP below) are genuinely the same concern
+    # (automatic performance timing), sharing the one performance_flusher above; see
+    # PerformanceInstrumentation for the actual transaction_name/skip decisions each one makes,
+    # kept out of these blocks specifically so that decision logic is unit-testable without a real
+    # Rails/ActiveJob boot (this gem's own test suite doesn't require Rails at all; see that
+    # file's own comment).
+    initializer "forge_ops_tracker.track_performance" do
+      configuration = ForgeOpsTracker.configuration
+      flusher = Railtie.performance_flusher
+
+      ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
+        next unless configuration.track_performance && configuration.enabled?
+
+        event = ActiveSupport::Notifications::Event.new(*args)
+        transaction_name = PerformanceInstrumentation.controller_transaction_name(event.payload)
+        flusher.record(transaction_name: transaction_name, duration_ms: event.duration, kind: "controller")
+      end
+
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        next unless configuration.track_performance && configuration.enabled?
+
+        event = ActiveSupport::Notifications::Event.new(*args)
+        transaction_name = PerformanceInstrumentation.query_transaction_name(event.payload)
+        next if transaction_name.nil? # SCHEMA/cached, see PerformanceInstrumentation's own comment
+
+        flusher.record(transaction_name: transaction_name, duration_ms: event.duration, kind: "query")
+      end
+
+      ActiveSupport::Notifications.subscribe("perform.active_job") do |*args|
+        next unless configuration.track_performance && configuration.enabled?
+
+        event = ActiveSupport::Notifications::Event.new(*args)
+        transaction_name = PerformanceInstrumentation.job_transaction_name(event.payload)
+        flusher.record(transaction_name: transaction_name, duration_ms: event.duration, kind: "job")
+      end
+    end
+
+    # Raw (non-ActiveJob) Sidekiq::Worker job timing, plus Sidekiq's own queue-depth/processed/
+    # failed/etc. gauges: a separate initializer, since unlike ActiveRecord/ActionController
+    # (always present in any Rails app this gem's own gemspec already implies), Sidekiq is
+    # genuinely optional and isn't a declared dependency of this gem at all.
+    initializer "forge_ops_tracker.track_sidekiq" do
+      next unless defined?(::Sidekiq)
+
+      require "forge_ops_tracker/integrations/sidekiq"
+
+      configuration = ForgeOpsTracker.configuration
+      ::Sidekiq.configure_server do |config|
+        config.server_middleware do |chain|
+          # No extra args to chain.add: Sidekiq calls Middleware.new(*args) itself for every job,
+          # splatting whatever was passed here; the middleware's own keyword-argument defaults
+          # (ForgeOpsTracker.configuration, Railtie.performance_flusher) already resolve correctly
+          # when called with none, and passing a keyword hash through *args here is genuinely
+          # ambiguous (Sidekiq's own chain.add doc example passes a literal positional Hash, not
+          # keyword syntax, for exactly this reason).
+          chain.add ForgeOpsTracker::Integrations::Sidekiq::Middleware
+        end
+      end
+
+      ForgeOpsTracker::Integrations::Sidekiq::StatsReporter.start(configuration: configuration)
+    end
+
+    initializer "forge_ops_tracker.track_solid_queue" do
+      next unless defined?(::SolidQueue)
+
+      require "forge_ops_tracker/integrations/solid_queue"
+      ForgeOpsTracker::Integrations::SolidQueue::StatsReporter.start(configuration: ForgeOpsTracker.configuration)
+    end
+
+    initializer "forge_ops_tracker.track_puma" do
+      next unless defined?(::Puma)
+
+      require "forge_ops_tracker/integrations/puma"
+      ForgeOpsTracker::Integrations::Puma::StatsReporter.start(configuration: ForgeOpsTracker.configuration)
+    end
+
+    # Net::HTTP is always present (Ruby's own standard library), so this always prepends; the
+    # actual on/off decision happens at call time inside Timing#request itself (checking
+    # configuration.track_performance/enabled? the same way the subscriptions above do), so
+    # toggling that flag after boot still takes effect immediately, the same as every other
+    # automatic instrumentation point in this gem.
+    initializer "forge_ops_tracker.track_net_http" do
+      require "forge_ops_tracker/integrations/net_http"
+      Net::HTTP.prepend(ForgeOpsTracker::Integrations::NetHTTP::Timing)
+    end
   end
 end

data/lib/forge_ops_tracker/session_flusher.rb

@@ -0,0 +1,85 @@
+require "thread"
+
+module ForgeOpsTracker
+  # Counts requests and crashes in-process (see Middleware::SessionTracking) and periodically
+  # flushes the totals as one small aggregate report, rather than one network call per request.
+  # Same "lazily start a background thread on first use, not at load time" pattern DeliveryQueue
+  # already uses, so each forked Puma/Passenger worker gets its own fresh thread instead of
+  # inheriting a dead one across fork; here it's triggered by a sleep-loop timer instead of a
+  # queue push, since there's no per-event signal to wait on, just a clock.
+  class SessionFlusher
+    def initialize(configuration, client: Client.new(configuration))
+      @configuration = configuration
+      @client = client
+      @mutex = Mutex.new
+      @sessions_count = 0
+      @crashed_sessions_count = 0
+      @period_started_at = Time.now.utc
+      @thread = nil
+
+      # Flushes whatever's already tallied on a normal process exit, so the last partial window
+      # (anything shorter than a full session_flush_interval) isn't silently dropped.
+      at_exit { flush }
+    end
+
+    def record_session(crashed:)
+      ensure_worker_started
+
+      @mutex.synchronize do
+        @sessions_count += 1
+        @crashed_sessions_count += 1 if crashed
+      end
+    end
+
+    # Snapshots and resets the in-process counters, then delivers them. A failed delivery keeps
+    # the counts where they are rather than resetting, so the next flush's window just grows
+    # instead of losing what was already tallied; there's no other copy of this data anywhere.
+    def flush
+      snapshot = nil
+
+      @mutex.synchronize do
+        return if @sessions_count.zero?
+
+        snapshot = {
+          release: configuration.release,
+          environment: configuration.environment.to_s,
+          period_started_at: @period_started_at.iso8601,
+          period_ended_at: Time.now.utc.iso8601,
+          sessions_count: @sessions_count,
+          crashed_sessions_count: @crashed_sessions_count
+        }
+      end
+
+      return unless snapshot && client.deliver_session_checkin(snapshot)
+
+      @mutex.synchronize do
+        @sessions_count = 0
+        @crashed_sessions_count = 0
+        @period_started_at = Time.now.utc
+      end
+    end
+
+    private
+      attr_reader :configuration, :client
+
+      def ensure_worker_started
+        return if @thread&.alive?
+
+        @mutex.synchronize do
+          return if @thread&.alive?
+
+          @thread = Thread.new { run }
+          @thread.abort_on_exception = false
+        end
+      end
+
+      def run
+        loop do
+          sleep configuration.session_flush_interval
+          flush
+        rescue StandardError => e
+          configuration.logger&.debug { "[ForgeOpsTracker] session flush thread error: #{e.class}: #{e.message}" }
+        end
+      end
+  end
+end

data/lib/forge_ops_tracker/version.rb

@@ -1,3 +1,3 @@
 module ForgeOpsTracker
-  VERSION = "0.2.1"
+  VERSION = "0.7.0"
 end

data/lib/forge_ops_tracker.rb

@@ -5,6 +5,14 @@ require "forge_ops_tracker/event_builder"
 require "forge_ops_tracker/client"
 require "forge_ops_tracker/delivery_queue"
 require "forge_ops_tracker/error_subscriber"
+require "forge_ops_tracker/session_flusher"
+require "forge_ops_tracker/performance_flusher"
+require "forge_ops_tracker/performance_instrumentation"
+require "forge_ops_tracker/metric_buffer"
+require "forge_ops_tracker/infrastructure_metric_buffer"
+require "forge_ops_tracker/periodic_poller"
+require "forge_ops_tracker/middleware/session_tracking"
+require "forge_ops_tracker/middleware/user_context"
 
 module ForgeOpsTracker
   class << self
@@ -15,6 +23,50 @@ module ForgeOpsTracker
     def configure
       yield configuration
     end
+
+    # Records a named business metric (a signup, a payment, anything a customer wants to name),
+    # buffered and flushed periodically as a batch rather than one network call per capture (see
+    # MetricBuffer). value defaults to 1.0 so a bare counter-style call ("a signup happened")
+    # needs no argument; pass an explicit one for a metric with a real magnitude ("a $49 payment
+    # happened"). A no-op, same as every other capture path in this gem, when the gem isn't
+    # enabled (no DSN configured, or the current environment isn't in enabled_environments).
+    def capture_metric(name, value: 1.0)
+      return unless configuration.enabled?
+
+      metric_buffer.record(metric_name: name, value: value)
+    end
+
+    # Records one infrastructure reading (CPU/memory/disk, or anything else a customer's own
+    # script reads) from one of their own hosts. hostname defaults to Configuration#server_name
+    # (already derived from Socket.gethostname), so a script running on the box it's reporting
+    # about doesn't need to pass one explicitly. Same buffered-batch delivery and no-op-when-
+    # disabled contract as capture_metric above.
+    def capture_infrastructure_metric(name, value:, hostname: nil)
+      return unless configuration.enabled?
+
+      infrastructure_metric_buffer.record(metric_name: name, value: value, hostname: hostname || configuration.server_name)
+    end
+
+    # Manually attaches an affected user to whatever gets reported for the rest of this request
+    # (or, outside a request entirely, in a background job or a console session, for the rest of
+    # this thread). Sets the same thread-local ForgeOpsTracker::Middleware::UserContext's own
+    # Warden auto-detection uses, so this composes with it rather than being a second, separate
+    # mechanism: call this after that middleware ran to override its guess, or call it standalone
+    # in an app with no Warden at all. id/email/username are all independently optional; a call
+    # with none of them (or all nil) clears whatever was set.
+    def set_user(id: nil, email: nil, username: nil)
+      user = { id: id, email: email, username: username }.compact
+      Thread.current[:forge_ops_tracker_current_user] = user.empty? ? nil : user
+    end
+
+    private
+      def metric_buffer
+        @metric_buffer ||= MetricBuffer.new(configuration)
+      end
+
+      def infrastructure_metric_buffer
+        @infrastructure_metric_buffer ||= InfrastructureMetricBuffer.new(configuration)
+      end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forge_ops_tracker
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.7.0
 platform: ruby
 authors:
 - ForgeOps
@@ -23,8 +23,50 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.13'
-description: Hooks Rails' error reporter and reports exceptions to a private ForgeOps
-  exception tracker instance over HTTP, without ever raising back into the host application.
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Hooks Rails' error reporter and reports exceptions to a ForgeOps exception
+  tracker instance over HTTP, without ever raising back into the host application.
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -38,8 +80,20 @@ files:
 - lib/forge_ops_tracker/delivery_queue.rb
 - lib/forge_ops_tracker/error_subscriber.rb
 - lib/forge_ops_tracker/event_builder.rb
+- lib/forge_ops_tracker/infrastructure_metric_buffer.rb
+- lib/forge_ops_tracker/integrations/net_http.rb
+- lib/forge_ops_tracker/integrations/puma.rb
+- lib/forge_ops_tracker/integrations/sidekiq.rb
+- lib/forge_ops_tracker/integrations/solid_queue.rb
+- lib/forge_ops_tracker/metric_buffer.rb
+- lib/forge_ops_tracker/middleware/session_tracking.rb
+- lib/forge_ops_tracker/middleware/user_context.rb
+- lib/forge_ops_tracker/performance_flusher.rb
+- lib/forge_ops_tracker/performance_instrumentation.rb
+- lib/forge_ops_tracker/periodic_poller.rb
 - lib/forge_ops_tracker/pii_scrubber.rb
 - lib/forge_ops_tracker/railtie.rb
+- lib/forge_ops_tracker/session_flusher.rb
 - lib/forge_ops_tracker/version.rb
 homepage: https://getforgeops.net
 licenses:
@@ -63,5 +117,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.11
 specification_version: 4
-summary: Rails exception reporting client for a self-hosted ForgeOps tracker
+summary: Rails exception reporting client for a ForgeOps tracker
 test_files: []