forge_ops_tracker 0.2.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 461cec25deb5d055e670ab0bf6e9fbc3cc7183fee4b9e7e731cbefabc4c615f3
-  data.tar.gz: d7fe09d86a29c7ecca952c0f9ee5bfaa839bdf8541c1d787e7b752e599c33347
+  metadata.gz: f15d33570709adad8c061ee0c432d9a6484fc50881076fae1493b892562188e7
+  data.tar.gz: f5fada725654a4006a6a44ee0680fb5f7f34cb808087305596892101c743a0ef
 SHA512:
-  metadata.gz: 50c03a3c07c566d8a665fcf79996ce41b4f5012e35bca1e369da9b1d1de71ebda6d429d25e025a3f15054f93287406d5656dd7e54ac4f6bc8b0ca6c6fa2497cb
-  data.tar.gz: 2ecb9ce97ec67a22b3f21d3e6945bdc3bd45f2c7199fd92834756d9081c3ccc25694d8226933a6c72de8f0efc4be4658dfe1061beba36c3998e45c181cba2f37
+  metadata.gz: 66513f4aebaeb443198a73bad548faaab86653841d213c37000bd343de406926053faa58b65be68934d90c8e12cc1393061ee763e7b5541c4545e90713910fb9
+  data.tar.gz: 86eb61aca41a42a55a6df37df0d8ef7789b5342055239640a593310da438cda20e3d6e959a0b229c4dbcbe137089e31d8bd537b1eb8d4e91c72bec4acfd6ec8c

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.5.0
+
+- Every reported event now carries `sdk_name` ("ruby"), so a project's language on the ForgeOps
+  dashboard auto-detects from whichever SDK is actually reporting into it, rather than staying
+  stuck on whatever it was created with. Never overrides a language picked by hand in project
+  settings.
+
+## 0.4.0
+
+- Session tracking (release health): every request is now counted as a session, crash-free unless
+  an unhandled exception actually escapes it, so the ForgeOps dashboard can show a crash-free rate
+  per release rather than only ever hearing about the requests that broke. Counted in-process and
+  flushed as a small periodic aggregate (`config.session_flush_interval`, default 60 seconds) on
+  its own background thread, not one network call per request. On by default, the same as error
+  tracking itself (`config.track_sessions = false` opts out); requires a ForgeOps plan that
+  includes release health, checked server-side on every flush.
+
+## 0.3.0
+
+- Source context capture: each in-app backtrace frame can now carry the 5 lines of source on
+  either side of the culprit line, read straight off disk at raise-time, so an issue's detail page
+  can show the actual code that broke, not just a file:line:method reference. On by default
+  (`config.capture_source_context = false` opts out), but the real, durable protection is a
+  per-project setting on the ForgeOps server, not this flag: turning it off there stops the server
+  from ever storing captured source lines for that project again, regardless of what any individual
+  app's own local setting is still set to. Never applies to a frame outside your app's own code,
+  and fails silently for any file that can't be read.
+
 ## 0.2.0
 
 - Client-side PII scrubbing: payloads are scrubbed (email addresses, formatted SSNs/credit

data/README.md

@@ -1,6 +1,6 @@
 # ForgeOpsTracker
 
-Rails exception reporting client for a private, self-hosted [ForgeOps](../../) tracker instance.
+Rails exception reporting client for a [ForgeOps](../../) instance.
 
 ## Installation
 
@@ -22,17 +22,17 @@ end
 ```
 
 Delivery happens on a small background thread with a bounded queue and short HTTP timeouts. Every
-failure mode -- network errors, timeouts, a full queue, a malformed DSN -- is caught and dropped
+failure mode (network errors, timeouts, a full queue, a malformed DSN) is caught and dropped
 rather than raised, so a broken or unreachable tracker can never take down the host app.
 
 ## What gets reported automatically, and what doesn't
 
 **Unhandled exceptions need no further wiring at all.** The gem's Railtie subscribes to
 `Rails.error` automatically, and Rails itself reports anything that crashes a request or job
-through that same channel -- install the gem, set a DSN, and those show up in ForgeOps with zero
+through that same channel: install the gem, set a DSN, and those show up in ForgeOps with zero
 other code changes.
 
-**Handled exceptions -- code that catches its own error to keep running -- are a different story.**
+**Handled exceptions (code that catches its own error to keep running) are a different story.**
 A plain `rescue` the gem never hears about, no matter what:
 
 ```ruby
@@ -40,19 +40,19 @@ begin
   charge_card(order)
 rescue Stripe::CardError => e
   logger.warn("card declined: #{e.message}")
-  # ForgeOps never sees this -- nothing here goes through Rails.error at all.
+  # ForgeOps never sees this: nothing here goes through Rails.error at all.
 end
 ```
 
 To report it *and* keep swallowing it, swap the bare `rescue` for Rails' own built-in
-`Rails.error.handle` -- this isn't a ForgeOps-specific API, it's Rails' own error-reporting
+`Rails.error.handle`: this isn't a ForgeOps-specific API, it's Rails' own error-reporting
 convention (Rails 7+), which the gem just happens to already be subscribed to:
 
 ```ruby
 Rails.error.handle(fallback: -> { nil }) do
   charge_card(order)
 end
-# Reported to every Rails.error subscriber, including this gem, then swallowed --
+# Reported to every Rails.error subscriber, including this gem, then swallowed:
 # execution continues past the block either way.
 ```
 
@@ -70,8 +70,8 @@ code already catches and handles it, route that specific `rescue` through `Rails
 ## PII scrubbing
 
 By default, the message, backtrace, and any context/tags you attach are scanned for likely
-personal data -- email addresses, formatted SSNs/credit cards, known API key/token formats, and
-anything under a suspiciously-named key (`password`, `api_key`, `ssn`, and similar) -- and redacted
+personal data: email addresses, formatted SSNs/credit cards, known API key/token formats, and
+anything under a suspiciously-named key (`password`, `api_key`, `ssn`, and similar); redacted
 before the payload ever leaves this process. ForgeOps itself scrubs again on arrival regardless, so
 this is a second, earlier layer, not the only one.
 
@@ -83,3 +83,44 @@ ForgeOpsTracker.configure do |config|
   config.scrub_pii = false
 end
 ```
+
+## Source context
+
+By default, each in-app backtrace frame (never a vendored gem) is captured along with the 5 lines
+of source on either side of the culprit line, read straight off disk at raise-time, so an issue's
+detail page can show the actual code that broke, not just a `file:line:method` reference. This
+never applies to a frame outside `app_root`, and it fails silently (no context, not an error) for
+any file that can't be read for whatever reason.
+
+This is a real, deliberate exception to "off by default is safer": literal source code is being
+transmitted, not just a reference to it, and the real protection here is not this flag. Every
+project on ForgeOps has its own setting (on by default, off durably and immediately once an org
+owner turns it off, regardless of what any individual app's own `config.capture_source_context` is
+still set to) that governs whether the server will ever actually store what an SDK sends; see the
+in-app help docs. Use this flag if you'd rather this gem never even attempt the disk read in the
+first place:
+
+```ruby
+ForgeOpsTracker.configure do |config|
+  config.capture_source_context = false
+end
+```
+
+## Session tracking (release health)
+
+By default, every request is counted as a session: crash-free unless an unhandled exception
+actually escapes it, giving ForgeOps a crash-free rate per release to show alongside the errors
+themselves, not just the errors on their own. Counted in-process and flushed as a small periodic
+aggregate on a background thread (never one network call per request), the same delivery
+philosophy as everything else in this gem: a broken or unreachable tracker never affects the host
+app either way.
+
+```ruby
+ForgeOpsTracker.configure do |config|
+  config.track_sessions = false   # opt out entirely
+  config.session_flush_interval = 30 # seconds; default 60
+end
+```
+
+Requires a ForgeOps plan that includes release health; on a plan that doesn't, the periodic
+flushes are simply rejected server-side and dropped, exactly like any other delivery failure.

data/lib/forge_ops_tracker/client.rb

@@ -3,8 +3,8 @@ require "json"
 require "uri"
 
 module ForgeOpsTracker
-  # Delivers one payload over HTTP. Every failure mode -- DNS, connection,
-  # timeout, TLS, a non-2xx response -- is caught here and turned into a
+  # Delivers one payload over HTTP. Every failure mode; DNS, connection,
+  # timeout, TLS, a non-2xx response; is caught here and turned into a
   # `false` return rather than a raised exception, since a broken or
   # unreachable tracker must never be able to break the host app.
   class Client
@@ -13,19 +13,29 @@ module ForgeOpsTracker
     end
 
     def deliver(payload)
-      uri = configuration.ingestion_uri
-      return false unless uri
-
-      response = http_for(uri).request(build_request(uri, payload))
-      response.is_a?(Net::HTTPSuccess)
-    rescue StandardError => e
-      log { "delivery failed: #{e.class}: #{e.message}" }
-      false
+      post(configuration.ingestion_uri, payload)
+    end
+
+    # Same delivery contract as deliver above (never raises, returns a bare
+    # true/false), just a different endpoint under the same DSN's host and
+    # api_key; see Configuration#session_checkins_uri.
+    def deliver_session_checkin(payload)
+      post(configuration.session_checkins_uri, payload)
     end
 
     private
       attr_reader :configuration
 
+      def post(uri, payload)
+        return false unless uri
+
+        response = http_for(uri).request(build_request(uri, payload))
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError => e
+        log { "delivery failed: #{e.class}: #{e.message}" }
+        false
+      end
+
       def http_for(uri)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = uri.scheme == "https"

data/lib/forge_ops_tracker/configuration.rb

@@ -3,10 +3,12 @@ require "socket"
 
 module ForgeOpsTracker
   class Configuration
-    # A single Sentry-style DSN string carries both the ingestion URL and
+    # A single DSN string carries both the ingestion URL and
     # the project's api_key: "https://<api_key>@host/api/v1/events".
     attr_accessor :dsn, :environment, :release, :server_name, :app_root, :logger
     attr_accessor :enabled_environments, :queue_size, :open_timeout, :read_timeout, :scrub_pii
+    attr_accessor :capture_source_context
+    attr_accessor :track_sessions, :session_flush_interval
 
     def initialize
       @dsn = ENV["FORGE_OPS_DSN"]
@@ -18,13 +20,29 @@ module ForgeOpsTracker
       @open_timeout = 2
       @read_timeout = 2
       @logger = nil
-      # See PiiScrubber -- redacts likely-sensitive content (emails,
+      # See PiiScrubber; redacts likely-sensitive content (emails,
       # credit cards, known API key formats, anything under a
       # suspiciously-named key) before a payload ever leaves this
       # process. ForgeOps itself scrubs again on arrival regardless, so
-      # this is a second, earlier layer, not the only one -- but "on" is
+      # this is a second, earlier layer, not the only one; but "on" is
       # the only sane default.
       @scrub_pii = true
+      # Whether EventBuilder reads a few lines of source off disk around
+      # each in-app frame's culprit line (see EventBuilder#attach_source_context).
+      # Defaults on so a snippet shows up without extra setup, but this flag
+      # alone isn't the real protection against sending proprietary source
+      # code somewhere it shouldn't go: ForgeOps' own per-project setting is
+      # the durable, server-enforced off switch, since it applies regardless
+      # of what this flag happens to be set to on any given deployment, and
+      # can't drift back on the way a local config value could. Turn this
+      # off here too if this host app never wants that disk read attempted
+      # in the first place.
+      @capture_source_context = true
+      # Auto-instruments every request the moment the gem loads, the same "on unless you turn it
+      # off" default error tracking itself already has; nothing else in this gem is opt-in. See
+      # ForgeOpsTracker::Middleware::SessionTracking for what this actually wraps.
+      @track_sessions = true
+      @session_flush_interval = 60
     end
 
     def api_key
@@ -42,6 +60,18 @@ module ForgeOpsTracker
       uri
     end
 
+    # Same host and api_key as ingestion_uri, a sibling path under the same DSN rather than a
+    # second DSN to configure; the DSN's own path is always /api/v1/events (what ForgeOps issues
+    # to every project), so the session-checkins endpoint is derived by substitution.
+    def session_checkins_uri
+      uri = ingestion_uri
+      return nil unless uri
+
+      uri = uri.dup
+      uri.path = uri.path.sub(%r{/events\z}, "/session_checkins")
+      uri
+    end
+
     def enabled?
       !blank?(dsn) && !blank?(api_key) && enabled_environments.map(&:to_s).include?(environment.to_s)
     end

data/lib/forge_ops_tracker/delivery_queue.rb

@@ -17,7 +17,7 @@ module ForgeOpsTracker
     end
 
     # Enqueues a payload, dropping it silently (never blocking the caller)
-    # if the queue is already full -- a burst of exceptions must never apply
+    # if the queue is already full; a burst of exceptions must never apply
     # backpressure to the host app.
     def push(payload)
       ensure_worker_started

data/lib/forge_ops_tracker/event_builder.rb

@@ -2,13 +2,27 @@ require "time"
 
 module ForgeOpsTracker
   # Turns a raised exception into the JSON-able payload shape the ingestion
-  # API expects. Backtrace parsing is a simple regex, not a full parser --
+  # API expects. Backtrace parsing is a simple regex, not a full parser:
   # good enough for standard MRI backtrace lines across Ruby versions
   # (both the older `in \`method'` and newer `in 'method'` quoting styles).
   class EventBuilder
     LINE_PATTERN = /\A(?<file>.+?):(?<line>\d+)(?::in\s+(?<method>.+))?\z/
     MAX_FRAMES = 500
 
+    # Identifies this gem to the server's auto language-detection on the project the event lands
+    # in (see Project#note_sdk_platform server-side); "ruby", matching this repo's own sdks/
+    # directory naming for every other language's client.
+    SDK_NAME = "ruby".freeze
+
+    # How many lines of source to grab on either side of the culprit line
+    # (see #attach_source_context), and the longest a single captured line
+    # is allowed to be before getting truncated; guards against a single
+    # pathological minified/generated line ballooning the payload. ForgeOps
+    # itself re-truncates on arrival too, the same "don't just trust the
+    # SDK" posture MAX_FRAMES already gets on the server side.
+    CONTEXT_LINES = 5
+    MAX_CONTEXT_LINE_LENGTH = 500
+
     def initialize(configuration)
       @configuration = configuration
     end
@@ -23,7 +37,8 @@ module ForgeOpsTracker
         release: configuration.release,
         server_name: configuration.server_name,
         context: context || {},
-        tags: {}
+        tags: {},
+        sdk_name: SDK_NAME
       }
       scrub(payload)
     end
@@ -31,8 +46,8 @@ module ForgeOpsTracker
     private
       attr_reader :configuration
 
-      # exception_class/occurred_at/environment/release/server_name are
-      # left alone -- structured fields this gem or the host app sets
+      # exception_class/occurred_at/environment/release/server_name/sdk_name are
+      # left alone; structured fields this gem or the host app sets
       # deliberately, not free text an exception or its context could
       # accidentally spill sensitive data into.
       def scrub(payload)
@@ -55,12 +70,13 @@ module ForgeOpsTracker
         return nil unless match
 
         file = match[:file]
-        {
+        frame = {
           file: file,
           line: match[:line].to_i,
           method: match[:method]&.gsub(/\A[`'"]|['"]\z/, ""),
           in_app: in_app?(file)
         }
+        attach_source_context(frame)
       end
 
       def in_app?(file)
@@ -69,5 +85,43 @@ module ForgeOpsTracker
 
         file.start_with?(root.to_s) && !file.include?("/gems/") && !file.include?("/bundle/")
       end
+
+      # Reads a few lines of source straight off disk around the culprit
+      # line, at raise-time, in the same running process the exception came
+      # from. Gated on two things: the frame has to be in-app (never a
+      # vendored dependency; there'd be nothing meaningful to show, and
+      # it's not the host app's own code to begin with), and
+      # configuration.capture_source_context has to be on (see
+      # Configuration for why it defaults to true and why ForgeOps' own
+      # per-project setting, not this flag, is the durable, protected way
+      # to turn it off). Best-effort: any file that can't be read (deleted,
+      # permission denied, a path that only ever existed inside a build
+      # step and isn't present in this deployment) just means this one
+      # frame gets no source context, not a raised error of its own.
+      def attach_source_context(frame)
+        return frame unless configuration.capture_source_context && frame[:in_app]
+
+        lines = File.readlines(frame[:file])
+        index = frame[:line] - 1
+        return frame unless index.between?(0, lines.length - 1)
+
+        from = [ index - CONTEXT_LINES, 0 ].max
+        to = [ index + CONTEXT_LINES, lines.length - 1 ].min
+
+        frame.merge(
+          context_line: truncate_line(lines[index]),
+          pre_context: lines[from...index].map { |source_line| truncate_line(source_line) },
+          post_context: lines[(index + 1)..to].map { |source_line| truncate_line(source_line) }
+        )
+      rescue SystemCallError, IOError
+        frame
+      end
+
+      def truncate_line(line)
+        line = line.chomp
+        return line if line.length <= MAX_CONTEXT_LINE_LENGTH
+
+        "#{line[0, MAX_CONTEXT_LINE_LENGTH]}..."
+      end
   end
 end

data/lib/forge_ops_tracker/middleware/session_tracking.rb

@@ -0,0 +1,38 @@
+module ForgeOpsTracker
+  module Middleware
+    # Wraps every request: counts it, and separately counts it as crashed only when an exception
+    # actually escapes to here, never inferred from whether ErrorSubscriber happened to report
+    # anything, since ErrorSubscriber reports handled errors too (see Rails.error.handle), so "an
+    # event was reported" and "this request crashed" aren't the same signal. Always re-raises,
+    # so the host app's own error handling and ErrorSubscriber both run completely unaffected by
+    # this middleware's presence; it only ever observes, never intercepts.
+    class SessionTracking
+      def initialize(app, configuration: ForgeOpsTracker.configuration, flusher: nil)
+        @app = app
+        @configuration = configuration
+        @flusher = flusher
+      end
+
+      def call(env)
+        return app.call(env) unless configuration.track_sessions && configuration.enabled?
+
+        begin
+          response = app.call(env)
+        rescue StandardError
+          flusher_instance.record_session(crashed: true)
+          raise
+        end
+
+        flusher_instance.record_session(crashed: false)
+        response
+      end
+
+      private
+        attr_reader :app, :configuration
+
+        def flusher_instance
+          @flusher ||= SessionFlusher.new(configuration)
+        end
+    end
+  end
+end

data/lib/forge_ops_tracker/pii_scrubber.rb

@@ -1,11 +1,11 @@
 module ForgeOpsTracker
   # Redacts likely-sensitive content out of a payload before it ever leaves
-  # this process -- the same patterns ForgeOps itself applies again on
+  # this process; the same patterns ForgeOps itself applies again on
   # arrival (defense in depth: this layer keeps the data off the wire and
   # out of any request logging in between; the server-side layer is what
   # actually protects the database, and doesn't depend on every reporting
   # app running an up-to-date version of this gem). See the main
-  # application's PiiScrubber for the shared design rationale -- kept as a
+  # application's PiiScrubber for the shared design rationale; kept as a
   # separate, dependency-free implementation here rather than requiring the
   # private app's code, since this gem has to work standalone in any host
   # app regardless of what's reporting into it.

data/lib/forge_ops_tracker/railtie.rb

@@ -10,5 +10,9 @@ 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
   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.5.0"
 end

data/lib/forge_ops_tracker.rb

@@ -5,6 +5,8 @@ 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/middleware/session_tracking"
 
 module ForgeOpsTracker
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forge_ops_tracker
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.5.0
 platform: ruby
 authors:
 - ForgeOps
@@ -23,8 +23,8 @@ 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.
+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 +38,10 @@ 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/middleware/session_tracking.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 +65,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: []