oopsie_exceptions 0.1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38724bd4e7e3113063179a4306f5207544e2c8933491ab429433d5294c00f04a
-  data.tar.gz: c42960e5299dfce450d2cd7992cc3fe5acf1c92ab667c41c555a2c8b90a258a5
+  metadata.gz: a3c1bf7176b541c4c19f09ca56724e8c873e1bae149ac9ff9963a4f4fb4f1156
+  data.tar.gz: 692fd55d89e3235279b1ba98764f1fbeaeab5e11204c3733674f7a8958956262
 SHA512:
-  metadata.gz: aa0c4ed76d142a98fc0b1097ad6956a637296eaa0da494762d839c2b94aecd4eabd061cc5d18e6c22113652ab401e2d74d6767ac86bccaed9c77ea620b990e7e
-  data.tar.gz: 39de699f9980f8151a55098257c75b50b000300718031baea8b9b8322cd96d8cb49f766a41dfddec615338d3835ece207b0192438f2730146df69d67a8427c48
+  metadata.gz: 0c8a3bfd9907819f35ecd979d114e9784daf71ff7c5b2264246782458463c15271a71319208fe5798de1c11178c7bf643e8bcda693124ed74e7f2a50cc25ef17
+  data.tar.gz: 9d4f5168d31b516127abc0afa2e894ec02c28cdf076e82f96d555f81c1e38fb3884d3fbca46307572ce2f9749798cf1ace9c4e2fa6d98a6263908c4a695a14a1

data/README.md

@@ -2,7 +2,7 @@
 
 Lightweight exception capture and webhook delivery for Rails. Like Sentry/Rollbar, but self-hosted and webhook-driven.
 
-Captures unhandled exceptions from web requests and background jobs, enriches them with request/user/server context, and delivers structured JSON payloads to configurable webhook endpoints.
+Captures unhandled exceptions from web requests and background jobs, enriches them with request/user/server context, and POSTs structured JSON payloads to one or more webhook endpoints.
 
 ## Installation
 
@@ -18,49 +18,99 @@ Then run the install generator:
 bin/rails generate oopsie_exceptions:install
 ```
 
-This creates:
-- `config/initializers/oopsie_exceptions.rb` — configuration
-- `app/jobs/oopsie_exceptions/delivery_job.rb` — async webhook delivery
+That creates a single file: `config/initializers/oopsie_exceptions.rb`. No code lands in `app/` — the Rack middleware, Rails error subscriber, ActiveJob hook, and webhook delivery job all live inside the gem.
 
 ## Configuration
 
-Edit `config/initializers/oopsie_exceptions.rb`:
+The most common pattern is to configure a different webhook per environment, with the URL and auth token coming from environment variables. Here's a real-world initializer:
 
 ```ruby
+# config/initializers/oopsie_exceptions.rb
 OopsieExceptions.configure do |config|
-  config.add_webhook "https://your-endpoint.com/webhooks/exceptions",
-    headers: { "Authorization" => "Bearer #{ENV['OOPSIE_WEBHOOK_TOKEN']}" }
+  if Rails.env.development?
+    config.add_webhook(
+      "http://localhost:3099/api/v1/exceptions",
+      headers: { "Authorization" => "Bearer #{ENV['OOPSIE_DEV_TOKEN']}" },
+      name: "oopsie-local"
+    )
+    config.async_delivery = false
+  end
+
+  if Rails.env.production?
+    config.add_webhook(
+      "https://oopsie.example.com/api/v1/exceptions",
+      headers: { "Authorization" => "Bearer #{ENV['OOPSIE_PROD_TOKEN']}" },
+      name: "oopsie-prod"
+    )
+    config.async_delivery = true
+  end
 
   config.app_name = "MyApp"
   config.environment = Rails.env
-  config.enabled = Rails.env.production?
+  config.filter_parameters = %w[password password_confirmation secret token api_key]
+  config.enabled = Rails.env.development? || Rails.env.production?
+
+  # Attach the current user and controller#action to every exception.
+  # `env` is the Rack env — runs once per request.
+  config.context_builder = ->(env) {
+    warden = env["warden"]
+    user = warden&.user
+    params = env["action_dispatch.request.path_parameters"]
+    {
+      user: user ? { id: user.id, email: user.email } : nil,
+      action: params ? "#{params[:controller]}##{params[:action]}" : nil
+    }.compact
+  }
 end
 ```
 
-## What happens automatically
+### Configuration options
 
-- **Rack middleware** inserted after `DebugExceptions` catches unhandled exceptions
-- **Rails.error subscriber** captures framework-reported errors
-- Request context (URL, IP, params, headers) is collected automatically
-- Webhooks are delivered async via ActiveJob
+| Option | Default | Description |
+| --- | --- | --- |
+| `add_webhook(url, headers:, name:)` | — | Register a webhook. Call multiple times for fan-out. |
+| `app_name` | Rails app module name | Identifier sent in every payload. |
+| `environment` | `Rails.env` | Environment label sent in every payload. |
+| `enabled` | `true` | Master kill switch. Set false in test/dev. |
+| `async_delivery` | `true` | Deliver via ActiveJob. Set false to POST inline. |
+| `filter_parameters` | `password, secret, token, api_key, ...` | Param names to redact in payloads. |
+| `filter_headers` | `Authorization, Cookie, Set-Cookie` | Headers to strip from payloads. |
+| `capture_request_body` | `false` | Include first 10KB of JSON request bodies. |
+| `ignored_exceptions` | 404s, routing errors, etc. | Exception class names to silently drop. |
+| `ignore_exception(*names)` | — | Append to `ignored_exceptions`. |
+| `context_builder` | `nil` | `->(env) { Hash }` — extra context per request. |
+| `before_notify` | `nil` | `->(payload) { payload }` — mutate or drop payloads. |
+| `timeout` / `open_timeout` | `10` / `5` | HTTP timeouts (seconds). |
 
-## Adding user context
+## What gets captured automatically
 
-In your `ApplicationController`:
+- **Web requests** — A Rack middleware inserted after `ActionDispatch::DebugExceptions` catches unhandled exceptions and 5xx responses.
+- **Background jobs** — `ActiveJob::Base.execute` is wrapped at the class level (the same approach Appsignal uses), so every queue adapter (Solid Queue, Sidekiq, Async, etc.) is covered. Catches `DeserializationError` and missing job classes too.
+- **`Rails.error` reports** — Subscribed via `Rails.error.subscribe`, so anything reported through the framework error reporter (`Rails.error.report` / `Rails.error.handle`) flows through.
+
+Each captured exception is enriched with request URL/method/IP/params/headers, the current user (via `context_builder` or `set_context`), server hostname/PID/Ruby version, and a UTC timestamp.
+
+## Adding context per-request
+
+If you don't want to use `context_builder`, you can set context from a controller:
 
 ```ruby
-before_action :set_oopsie_context
+class ApplicationController < ActionController::Base
+  before_action :set_oopsie_context
 
-private
+  private
 
-def set_oopsie_context
-  OopsieExceptions.set_context(
-    user: current_user ? { id: current_user.id, email: current_user.email } : nil,
-    action: "#{self.class.name}##{action_name}"
-  )
+  def set_oopsie_context
+    OopsieExceptions.set_context(
+      user: current_user ? { id: current_user.id, email: current_user.email } : nil,
+      action: "#{self.class.name}##{action_name}"
+    )
+  end
 end
 ```
 
+`context_builder` is preferred — it runs in the middleware before the request hits any controller, so it captures context even on errors raised before `before_action` runs.
+
 ## Manual reporting
 
 ```ruby
@@ -71,38 +121,89 @@ rescue => e
 end
 ```
 
+Or scope context to a block:
+
+```ruby
+OopsieExceptions.with_context(tenant_id: 42) do
+  do_work
+end
+```
+
 ## Multiple webhooks
 
 ```ruby
-config.add_webhook "https://your-api.com/exceptions"
+config.add_webhook "https://your-api.com/exceptions",
+  headers: { "Authorization" => "Bearer #{ENV['PRIMARY_TOKEN']}" }
+
 config.add_webhook "https://hooks.slack.com/services/..."
 config.add_webhook "https://discord.com/api/webhooks/..."
 ```
 
-Each endpoint receives every exception.
+Each endpoint receives every exception. Failures on one webhook don't affect the others.
 
 ## Payload format
 
-Each webhook receives a JSON payload with:
+Each webhook receives a JSON POST with:
 
 - **exception** — class, message, backtrace, cause chain
 - **request** — URL, method, IP, params, headers, user agent
-- **context** — user info and custom data you set
+- **context** — `user`, `action`, `job`, plus anything you set via `context_builder` / `set_context`
 - **server** — hostname, PID, Ruby/Rails versions
-- **app** — name, environment
+- **app** — `app_name`, `environment`
 - **timestamp** — UTC ISO8601
+- **handled** — `true` for `OopsieExceptions.report(..., handled: true)`, `false` for unhandled
+
+## Filtering noise
+
+By default these are dropped:
+
+```
+ActionController::RoutingError
+ActionController::UnknownFormat
+ActionController::BadRequest
+ActionDispatch::Http::MimeNegotiation::InvalidType
+AbstractController::ActionNotFound
+ActiveRecord::RecordNotFound
+ActionController::UnknownHttpMethod
+```
 
-## Filtering
+Add your own:
 
-By default, common noise exceptions are ignored (404s, routing errors, `ActionController::BadRequest`, etc.). Sensitive parameters (`password`, `token`, `secret`, `api_key`) and headers (`Authorization`, `Cookie`) are automatically filtered from payloads.
+```ruby
+config.ignore_exception "MyApp::IgnorableError", "ThirdParty::Timeout"
+```
 
-Customize in your initializer:
+Sensitive params (`password`, `token`, `secret`, `api_key`) and headers (`Authorization`, `Cookie`, `Set-Cookie`) are redacted from payloads automatically.
+
+## Mutating or dropping payloads
 
 ```ruby
-config.ignored_exceptions += ["MyApp::IgnorableError"]
-config.filter_parameters += [:credit_card]
+config.before_notify = ->(payload) {
+  payload[:context][:deploy_sha] = ENV["GIT_SHA"]
+  return nil if payload[:exception][:message].include?("known noise")
+  payload
+}
 ```
 
+Return `nil` to drop the notification entirely.
+
+## Upgrading from earlier versions
+
+If you're coming from an older version of the gem that generated `app/jobs/oopsie_exceptions/delivery_job.rb` in your app, **delete that file**. The gem now ships its own `OopsieExceptions::WebhookJob` and the host-app file is obsolete.
+
+```bash
+rm app/jobs/oopsie_exceptions/delivery_job.rb
+rmdir app/jobs/oopsie_exceptions  # if empty
+```
+
+Or just re-run the install generator and it will detect and remove the legacy file for you:
+
+```bash
+bin/rails generate oopsie_exceptions:install
+```
+
+No initializer changes are required.
+
 ## License
 
 MIT — see [LICENSE.txt](LICENSE.txt).

data/lib/generators/oopsie_exceptions/install_generator.rb

@@ -5,32 +5,27 @@ module OopsieExceptions
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path("templates", __dir__)
 
-      desc "Creates an OopsieExceptions initializer and delivery job"
+      desc "Creates an OopsieExceptions initializer"
 
       def create_initializer
         template "initializer.rb", "config/initializers/oopsie_exceptions.rb"
       end
 
-      def create_delivery_job
-        template "delivery_job.rb", "app/jobs/oopsie_exceptions/delivery_job.rb"
+      def remove_legacy_delivery_job
+        legacy_path = "app/jobs/oopsie_exceptions/delivery_job.rb"
+        return unless File.exist?(File.join(destination_root, legacy_path))
+
+        say ""
+        say "Found legacy #{legacy_path} from a previous version.", :yellow
+        say "The gem now ships its own webhook job — this file is no longer used."
+        remove_file legacy_path
       end
 
       def show_post_install
         say ""
         say "OopsieExceptions installed!", :green
         say ""
-        say "Next steps:"
-        say "  1. Edit config/initializers/oopsie_exceptions.rb to add your webhook URLs"
-        say "  2. Optionally add user context in ApplicationController:"
-        say ""
-        say "     before_action :set_oopsie_context"
-        say ""
-        say "     def set_oopsie_context"
-        say "       OopsieExceptions.set_context("
-        say "         user: current_user ? { id: current_user.id, email: current_user.email } : nil,"
-        say "         action: \"\#{self.class.name}#\#{action_name}\""
-        say "       )"
-        say "     end"
+        say "Next step: edit config/initializers/oopsie_exceptions.rb and add your webhook URLs."
         say ""
       end
     end

data/lib/generators/oopsie_exceptions/templates/initializer.rb

@@ -1,8 +1,23 @@
 OopsieExceptions.configure do |config|
-  # Add webhook endpoints — exceptions get POSTed here as JSON
-  # config.add_webhook "https://your-endpoint.com/webhooks/exceptions",
-  #   headers: { "Authorization" => "Bearer <%= "#{ENV['OOPSIE_WEBHOOK_TOKEN']}" %>" },
-  #   name: "primary"
+  # Webhook endpoints — exceptions get POSTed as JSON.
+  # Configure per-environment so dev errors don't hit your prod tracker.
+  if Rails.env.development?
+    config.add_webhook(
+      "http://localhost:3099/api/v1/exceptions",
+      headers: { "Authorization" => "Bearer #{ENV['OOPSIE_DEV_TOKEN']}" },
+      name: "oopsie-local"
+    )
+    config.async_delivery = false
+  end
+
+  if Rails.env.production?
+    config.add_webhook(
+      "https://oopsie.example.com/api/v1/exceptions",
+      headers: { "Authorization" => "Bearer #{ENV['OOPSIE_PROD_TOKEN']}" },
+      name: "oopsie-prod"
+    )
+    config.async_delivery = true
+  end
 
   # config.add_webhook "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"
   # config.add_webhook "https://discord.com/api/webhooks/YOUR/DISCORD/WEBHOOK"
@@ -10,17 +25,26 @@ OopsieExceptions.configure do |config|
   config.app_name = Rails.application.class.module_parent_name
   config.environment = Rails.env
 
-  # Deliver webhooks async via ActiveJob (set false for sync delivery)
-  config.async_delivery = true
-
-  # Exceptions that won't be reported (404s, bot garbage, etc.)
-  # config.ignore_exception "ActionController::RoutingError"
-
   # Filter sensitive params from payloads (inherits from Rails by default)
   config.filter_parameters = Rails.application.config.filter_parameters.map(&:to_s)
 
-  # Set false to disable in dev/test
-  config.enabled = Rails.env.production? || Rails.env.staging?
+  # Master kill switch — leave off in test
+  config.enabled = Rails.env.development? || Rails.env.production?
+
+  # Exceptions that won't be reported (404s, bot garbage, etc.)
+  # config.ignore_exception "MyApp::IgnorableError"
+
+  # Attach the current user and controller#action to every exception.
+  # `env` is the Rack env — runs once per request, before any controller code.
+  # config.context_builder = ->(env) {
+  #   warden = env["warden"]
+  #   user = warden&.user
+  #   params = env["action_dispatch.request.path_parameters"]
+  #   {
+  #     user: user ? { id: user.id, email: user.email } : nil,
+  #     action: params ? "#{params[:controller]}##{params[:action]}" : nil
+  #   }.compact
+  # }
 
   # Optional: modify or drop payloads before sending
   # config.before_notify = ->(payload) {

data/lib/oopsie_exceptions/active_job_extension.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module OopsieExceptions
+  # Class-level extension for ActiveJob::Base. Wraps `execute(job_data)`, the
+  # entry point queue adapters call, so we capture every unhandled exception
+  # — including ones that fire before `perform` runs (e.g. DeserializationError,
+  # or a missing job class).
+  #
+  # This mirrors how Appsignal hooks ActiveJob (lib/appsignal/hooks/active_job.rb).
+  module ActiveJobExtension
+    def execute(job_data)
+      job_context = {
+        job: {
+          class: job_data["job_class"],
+          job_id: job_data["job_id"],
+          queue: job_data["queue_name"],
+          arguments: job_data["arguments"],
+          executions: job_data["executions"],
+          provider_job_id: job_data["provider_job_id"]
+        }.compact
+      }
+
+      OopsieExceptions.with_context(job_context) do
+        super
+      rescue Exception => exception
+        OopsieExceptions.report(
+          exception,
+          context: { namespace: "background_job" },
+          handled: false
+        )
+        raise
+      end
+    end
+  end
+end

data/lib/oopsie_exceptions/configuration.rb

@@ -7,13 +7,15 @@ module OopsieExceptions
                   :filter_headers, :capture_request_body,
                   :async_delivery, :timeout, :open_timeout,
                   :backtrace_cleaner, :before_notify,
-                  :enabled
+                  :context_builder, :logger, :enabled
 
     def initialize
       @webhook_urls = []
       @app_name = defined?(Rails) ? (Rails.application.class.module_parent_name rescue "App") : "App"
-      @environment = defined?(Rails) ? (Rails.env rescue "development") : "development"
+      @environment = defined?(Rails) ? (Rails.env rescue "development") : (ENV["RACK_ENV"] || "development")
       @ignored_exceptions = default_ignored_exceptions
+      @context_builder = nil
+      @logger = defined?(Rails.logger) && Rails.logger ? Rails.logger : nil
       @filter_parameters = %w[password password_confirmation secret token api_key]
       @filter_headers = %w[Authorization Cookie Set-Cookie]
       @capture_request_body = false

data/lib/oopsie_exceptions/context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rack"
+
 module OopsieExceptions
   module Context
     THREAD_KEY = :oopsie_exceptions_context
@@ -22,18 +24,18 @@ module OopsieExceptions
       end
 
       def from_rack_env(env)
-        request = ActionDispatch::Request.new(env)
+        request = Rack::Request.new(env)
         config = OopsieExceptions.configuration
 
         ctx = {
           request: {
-            url: request.original_url,
-            method: request.method,
-            ip: request.remote_ip,
-            user_agent: request.user_agent,
-            referer: request.referer,
-            request_id: request.request_id,
-            params: sanitize_params(request.filtered_parameters),
+            url: request.url,
+            method: request.request_method,
+            ip: request.ip,
+            user_agent: env["HTTP_USER_AGENT"],
+            referer: env["HTTP_REFERER"],
+            request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"],
+            params: sanitize_params(request.params, config),
             headers: extract_headers(env, config)
           }
         }
@@ -41,7 +43,7 @@ module OopsieExceptions
         if config.capture_request_body && request.content_type&.include?("application/json")
           body = request.body.read
           request.body.rewind
-          ctx[:request][:body] = body.truncate(10_000) if body.present?
+          ctx[:request][:body] = body[0, 10_000] if body && !body.empty?
         end
 
         ctx
@@ -49,8 +51,12 @@ module OopsieExceptions
 
       private
 
-      def sanitize_params(params)
-        params.except("controller", "action").to_h
+      def sanitize_params(params, config)
+        filtered = params.reject { |k, _| k == "controller" || k == "action" }
+        filter_keys = config.filter_parameters
+        filtered.each_with_object({}) do |(k, v), hash|
+          hash[k] = filter_keys.any? { |f| k.to_s.include?(f) } ? "[FILTERED]" : v
+        end
       rescue
         {}
       end

data/lib/oopsie_exceptions/middleware.rb

@@ -13,6 +13,11 @@ module OopsieExceptions
         request_context = Context.from_rack_env(env)
         Context.merge(request_context)
 
+        if OopsieExceptions.configuration.context_builder
+          extra = OopsieExceptions.configuration.context_builder.call(env)
+          Context.merge(extra) if extra.is_a?(Hash)
+        end
+
         response = @app.call(env)
 
         if response[0].to_i >= 500

data/lib/oopsie_exceptions/railtie.rb

@@ -6,6 +6,13 @@ module OopsieExceptions
       app.middleware.insert_after ActionDispatch::DebugExceptions, OopsieExceptions::Middleware
     end
 
+    initializer "oopsie_exceptions.active_job" do
+      ActiveSupport.on_load(:active_job) do
+        ::ActiveJob::Base.extend(OopsieExceptions::ActiveJobExtension)
+        require "oopsie_exceptions/webhook_job"
+      end
+    end
+
     initializer "oopsie_exceptions.error_subscriber", after: :load_config_initializers do
       if Rails.respond_to?(:error) && OopsieExceptions.configuration.enabled
         Rails.error.subscribe(OopsieExceptions::ErrorSubscriber.new)

data/lib/oopsie_exceptions/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OopsieExceptions
-  VERSION = "0.1.0"
+  VERSION = "1.1.0"
 end

data/lib/oopsie_exceptions/webhook_client.rb

@@ -27,30 +27,24 @@ module OopsieExceptions
         response = http.request(request)
 
         unless response.is_a?(Net::HTTPSuccess)
-          log_warn("Webhook #{webhook.name} responded #{response.code}: #{response.body.to_s[0, 500]}")
+          log(:warn, "Webhook #{webhook.name} responded #{response.code}: #{response.body.to_s[0, 500]}")
         end
 
         response
       rescue => e
-        log_error("Failed to deliver to #{webhook.name}: #{e.message}")
+        log(:error, "Failed to deliver to #{webhook.name}: #{e.message}")
         nil
       end
 
       private
 
-      def log_warn(message)
-        if defined?(Rails.logger) && Rails.logger
-          Rails.logger.warn("[OopsieExceptions] #{message}")
+      def log(level, message)
+        logger = OopsieExceptions.configuration.logger
+        formatted = "[OopsieExceptions] #{message}"
+        if logger
+          logger.send(level, formatted)
         else
-          warn("[OopsieExceptions] #{message}")
-        end
-      end
-
-      def log_error(message)
-        if defined?(Rails.logger) && Rails.logger
-          Rails.logger.error("[OopsieExceptions] #{message}")
-        else
-          warn("[OopsieExceptions] ERROR: #{message}")
+          warn(formatted)
         end
       end
     end

data/lib/oopsie_exceptions/webhook_job.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Webhook delivery job. Loaded from the Railtie inside on_load(:active_job),
+# so it's only defined when the host app has ActiveJob available.
+#
+# Inherits from ActiveJob::Base directly (not ApplicationJob) so the gem has
+# zero hard dependencies on host-app code.
+module OopsieExceptions
+  class WebhookJob < ActiveJob::Base
+    queue_as :default
+
+    discard_on StandardError do |_job, error|
+      logger = OopsieExceptions.configuration.logger
+      logger&.error("[OopsieExceptions] WebhookJob discarded permanently: #{error.message}")
+    end
+
+    retry_on Net::OpenTimeout, Net::ReadTimeout, wait: 5.seconds, attempts: 3
+
+    def perform(payload_json, webhook_url, headers_json)
+      webhook = OopsieExceptions::Configuration::Webhook.new(
+        url: webhook_url,
+        headers: JSON.parse(headers_json),
+        name: webhook_url
+      )
+
+      OopsieExceptions::WebhookClient.post(webhook, payload_json)
+    end
+  end
+end

data/lib/oopsie_exceptions.rb

@@ -7,6 +7,7 @@ require_relative "oopsie_exceptions/payload"
 require_relative "oopsie_exceptions/webhook_client"
 require_relative "oopsie_exceptions/middleware"
 require_relative "oopsie_exceptions/error_subscriber"
+require_relative "oopsie_exceptions/active_job_extension"
 require_relative "oopsie_exceptions/railtie" if defined?(Rails::Railtie)
 
 module OopsieExceptions
@@ -58,8 +59,8 @@ module OopsieExceptions
 
     def deliver(payload)
       configuration.webhook_urls.each do |webhook|
-        if configuration.async_delivery && defined?(OopsieExceptions::DeliveryJob)
-          DeliveryJob.perform_later(
+        if configuration.async_delivery && defined?(OopsieExceptions::WebhookJob)
+          WebhookJob.perform_later(
             payload.to_json,
             webhook.url,
             webhook.headers.to_json

metadata

@@ -1,60 +1,33 @@
 --- !ruby/object:Gem::Specification
 name: oopsie_exceptions
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Troy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-04 00:00:00.000000000 Z
+date: 2026-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: railties
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '7.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '7.0'
-- !ruby/object:Gem::Dependency
-  name: actionpack
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '7.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '2.0'
 description: Captures unhandled exceptions from web requests and background jobs,
   enriches them with request/user/server context, and delivers structured JSON payloads
-  to configurable webhook endpoints.
+  to configurable webhook endpoints. Works with any Rack-based framework; optional
+  Rails integration included.
 email:
 executables: []
 extensions: []
@@ -63,9 +36,9 @@ files:
 - LICENSE.txt
 - README.md
 - lib/generators/oopsie_exceptions/install_generator.rb
-- lib/generators/oopsie_exceptions/templates/delivery_job.rb
 - lib/generators/oopsie_exceptions/templates/initializer.rb
 - lib/oopsie_exceptions.rb
+- lib/oopsie_exceptions/active_job_extension.rb
 - lib/oopsie_exceptions/configuration.rb
 - lib/oopsie_exceptions/context.rb
 - lib/oopsie_exceptions/error_subscriber.rb
@@ -74,6 +47,7 @@ files:
 - lib/oopsie_exceptions/railtie.rb
 - lib/oopsie_exceptions/version.rb
 - lib/oopsie_exceptions/webhook_client.rb
+- lib/oopsie_exceptions/webhook_job.rb
 homepage: https://github.com/theinventor/oopsie_exceptions
 licenses:
 - MIT
@@ -96,8 +70,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
-summary: Lightweight exception capture and webhook delivery for Rails
+summary: Lightweight exception capture and webhook delivery for Ruby (framework-agnostic)
 test_files: []

data/lib/generators/oopsie_exceptions/templates/delivery_job.rb

@@ -1,21 +0,0 @@
-module OopsieExceptions
-  class DeliveryJob < ApplicationJob
-    queue_as :default
-
-    discard_on StandardError do |job, error|
-      Rails.logger.error("[OopsieExceptions] DeliveryJob failed permanently: #{error.message}")
-    end
-
-    retry_on Net::OpenTimeout, Net::ReadTimeout, wait: 5.seconds, attempts: 3
-
-    def perform(payload_json, webhook_url, headers_json)
-      webhook = OopsieExceptions::Configuration::Webhook.new(
-        url: webhook_url,
-        headers: JSON.parse(headers_json),
-        name: webhook_url
-      )
-
-      OopsieExceptions::WebhookClient.post(webhook, payload_json)
-    end
-  end
-end