rails_discord_notifier 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d11c790a2d82647c56a5c2e01a96e9be1d55dc89d5d7042c3b0f06baca195ff
-  data.tar.gz: 56f2cadcc53da57692a4e54ad203d5a818294f790bd3934fa514213df442b667
+  metadata.gz: 6527e49521148326dc463e191ed0fe51097c0625e7a09b89074615eb6b21f431
+  data.tar.gz: 3502ab8e704d8e0d995cdd17fb8d06fc36d9c6bae13122455cb33b013c9eff3c
 SHA512:
-  metadata.gz: d07906322b8103001b7185d6594a55ea09e271fe1aca239cf69e1a93aa0e316a7c0440e4268b40be6476c97432c44861b8bc83bed4d51a8c2318e09bf23ff807
-  data.tar.gz: 6a411b50c842d47a2944c12fd89d1f1e27dab0dd0aa1bf8285e1bdb0a38e3c2651454f2310012a7f2a5d3b4fc8374bb62d4802d6f7d7d02ccc6856a8acad3145
+  metadata.gz: 2933ce5afd5ee5ae228d589c4c556fdde5dee1def8146a07204fc2230b80ccdbe89dbcbd055786af2389653518d8518e3de564d1dc3147851a8236a50f48ac5f
+  data.tar.gz: 01a951280d579cac677a76e6e2120b9fb30b4c8c94fd584459423a0b4e1b7d65e8ab178584ef4e9b41178a216a3b010d2a0d34950d481e0ef341d28050609bc5

data/CHANGELOG.md

@@ -7,6 +7,55 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-10-28
+
+### Added
+
+- **Google Chat support.** Set `webhook_url` to a Google Chat incoming webhook
+  (`https://chat.googleapis.com/v1/spaces/…`) and reports are sent as a Google
+  Chat text message instead of a Discord embed. They are redacted and size-limited
+  the same way, and fit within Google Chat's 32,000 byte limit. `username` and
+  `avatar_url` don't apply to Google Chat.
+- `rails_discord_notifier test` also reads `GOOGLE_CHAT_WEBHOOK_URL`.
+
+### Security
+
+- **Chat markup in reports is defused for Google Chat.** Attacker-influenced
+  text (exception message, path, User-Agent) can no longer produce an
+  `<users/all>` mention or a `<url|text>` masked link.
+- **The CLI no longer echoes a rejected webhook URL.** The URL is a credential
+  and the output may land in CI logs.
+- **Message scrubbing can no longer stall the process.** On Ruby 3.1 the scrubber
+  regex took cubic time, so a request that put about 4 KB of text into an
+  exception message held the interpreter lock for about 13 seconds. Matching is
+  now linear on every supported Ruby.
+- **The scrubber catches more credential shapes:** `Authorization` values with
+  the `Bearer`, `Basic`, `Token`, `Digest` or `Negotiate` scheme, JSON and
+  `inspect`-style quoted keys (`"password":"x"`, `"password" => "x"`), and
+  passwords in URLs (`redis://:pw@host`, `postgres://user:pw@host`).
+- **`Rails.error` context and `config.context` are now filtered** with the same
+  parameter filter as request params, including nested values and
+  `ActionController::Parameters`. They were previously sent verbatim. If the
+  filter itself raises, the context is left out and a warning is logged.
+- **Delivery threads are capped at 10 in flight.** Before, an error storm
+  against a slow webhook started one thread per report without limit. Reports
+  beyond the cap are dropped and logged.
+
+### Fixed
+
+- **Text that isn't valid UTF-8 no longer drops the report.** A binary header
+  value (which Rack passes through) or a stray byte in an exception message made
+  JSON encoding fail. Invalid bytes are now replaced with `�`, and text in other
+  encodings (e.g. Windows-1252) is converted.
+
+### Changed
+
+- **Repeats are recognised by route, not path.** The throttle fingerprint uses
+  controller and action instead of the raw request path, so `/users/1`,
+  `/users/2` and `/users/1.json` hitting the same bug count as one error.
+- Delivery log lines no longer name Discord ("webhook rejected the message",
+  "rate limited by the webhook"). Update any log alerts that match the old text.
+
 ## [0.2.0] - 2026-09-17
 
 This release fixes three defects that could leak credentials or silently drop

data/README.md

@@ -1,6 +1,7 @@
 # RailsDiscordNotifier
 
-Send Rails exceptions to a Discord channel via an incoming webhook.
+Send Rails exceptions to a Discord channel or a Google Chat space via an
+incoming webhook.
 
 - Catches unhandled exceptions from **web requests** (Rack middleware) and from
   **background jobs, rake tasks and runners** (`Rails.error` subscriber, Rails 7.0+)
@@ -14,7 +15,7 @@ Send Rails exceptions to a Discord channel via an incoming webhook.
 ## Installation
 
 ```ruby
-gem "rails_discord_notifier", "~> 0.2"
+gem "rails_discord_notifier", "~> 0.3"
 ```
 
 ```bash
@@ -22,25 +23,40 @@ bundle install
 rails generate rails_discord_notifier:install
 ```
 
-Then set your webhook (Server Settings → Integrations → Webhooks → Copy URL):
+Then set your webhook. The gem works out which service it is from the URL.
+
+**Discord:** Server Settings → Integrations → Webhooks → Copy URL.
 
 ```bash
 export DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/…/…"
 ```
 
+**Google Chat:** open the space → Apps & integrations → Webhooks → Add webhook,
+then copy the URL. Your Workspace admin must allow incoming webhooks.
+
+```bash
+export GOOGLE_CHAT_WEBHOOK_URL="https://chat.googleapis.com/v1/spaces/…/messages?key=…&token=…"
+```
+
+The generated initializer reads `DISCORD_WEBHOOK_URL`, then
+`GOOGLE_CHAT_WEBHOOK_URL`. Treat either URL as a password: anyone holding it
+can post to your channel.
+
 ## Verify it works
 
 ```bash
 bundle exec rails_discord_notifier test
 ```
 
-This posts a real sample report to your webhook and prints what Discord said,
-so you find out now rather than during your next incident.
+This posts a real sample report to your webhook and prints what the service
+said, so you find out now rather than during your next incident. It reads
+`DISCORD_WEBHOOK_URL`, then `GOOGLE_CHAT_WEBHOOK_URL`, or takes `--webhook URL`
+(which ends up in your shell history, so prefer the environment variable).
 
 ## What a report looks like
 
-An embed titled with the failing request, followed by the details you need to
-find the error:
+In Discord, an embed titled with the failing request, followed by the details
+you need to find the error:
 
 ```
 Exception in POST /orders
@@ -55,22 +71,26 @@ Params       { "order": { "email": "", "card_token": "[FILTERED]" } }
 Backtrace    `app/controllers/orders_controller.rb:42:in 'create'` …
 ```
 
+In Google Chat, the same details as a single text message, with the params and
+backtrace in code blocks. Chat has no per-message sender name or avatar: those
+come from the name and avatar you gave the webhook when you created it.
+
 ## Configuration
 
 Everything is optional except `webhook_url`.
 
 | Option | Default | Description |
 |---|---|---|
-| `webhook_url` | `nil` | **Required.** Must be `https://` on `discord.com` or `discordapp.com`. Anything else leaves the notifier disabled. |
+| `webhook_url` | `nil` | **Required.** Must be `https://` on `discord.com`, `discordapp.com` or `chat.googleapis.com`. Anything else leaves the notifier disabled. |
 | `enabled` | `false` in development and test, `true` elsewhere | Master switch. |
-| `username` | `"Error Bot"` | Bot display name in Discord. |
-| `avatar_url` | `nil` | Bot avatar image. |
+| `username` | `"Error Bot"` | Bot display name. Discord only. |
+| `avatar_url` | `nil` | Bot avatar image. Discord only. |
 | `async` | `true` | Deliver on a separate thread so a failing request is not slowed down. |
 | `throttle_period` | `60` | Seconds to collapse repeats of the same error. `0` disables. |
 | `ignored_exceptions` | routing/404-style noise (see below) | Exception class names, matched including subclasses. |
 | `include_params` | `true` | Include filtered request parameters. |
 | `filter_parameters` | `[]` | Extra redaction matchers, unioned with your app's `config.filter_parameters` and the gem's built-in list. |
-| `backtrace_lines` | `10` | Backtrace lines to send, trimmed to fit Discord's field limit. |
+| `backtrace_lines` | `10` | Backtrace lines to send, trimmed to fit the message size limit. |
 | `open_timeout` / `read_timeout` / `write_timeout` | `2` / `5` / `5` | Seconds. |
 | `environment` | `Rails.env`, else `RAILS_ENV`/`RACK_ENV` | Shown as a field, and decides the `enabled` default. |
 | `release` | `nil` | Shown as a field; handy for matching an error to a deploy. |
@@ -115,16 +135,37 @@ Parameters and query strings are filtered recursively with
 
 Because it is a union, enabling this gem can never redact less than your
 application already does. To send no parameters at all, set
-`config.include_params = false`.
+`config.include_params = false`. The same filter applies to extra fields from
+`config.context` and from `Rails.error` context.
 
 Exception messages are free text rather than structured parameters, so they get
-a best-effort scrub instead: `token=abc`, `password="x"` and `Api_Key: abc` style
+a best-effort scrub instead: `token=abc`, `password="x"`, `Api_Key: abc`,
+`"password":"x"`, `Authorization: Bearer abc` and `redis://:password@host` style
 fragments are replaced with `[FILTERED]`. This catches the usual culprits (a
 database connection error carrying a password, an HTTP error carrying a URL with
 a token) but cannot be exhaustive the way parameter filtering is.
 
+Path segments are sent as they are. If a route puts a secret in the path (for
+example `/password_resets/:token`), move it to the query string or the body,
+where it is filtered.
+
 Request bodies, headers and cookies are never sent.
 
+In Google Chat, text like `<users/all>` or `<https://…|click here>` would become
+an @all mention or a disguised link. Since anyone who can make your app raise
+controls part of the report (the path, the User-Agent, often the exception
+message), the gem defuses these with an invisible zero-width space after each
+`<`. The report looks the same but can't ping the space or hide a link. The
+space is still there if you copy text out of the report (for example
+``in `<main>'`` from a backtrace), so retype the `<` if a search comes up empty.
+
+## Google Chat rate limits
+
+Google Chat accepts about one message per second per space, shared with
+anything else posting there. Repeats of the same error are already collapsed
+(`throttle_period`), but a burst of *different* errors beyond that rate is
+rejected by Google with HTTP 429. Those rejections are logged, not retried.
+
 ## Reporting an exception yourself
 
 ```ruby
@@ -144,6 +185,12 @@ end
 The middleware observes and re-raises, so it never changes how your application
 handles errors. When both entry points see the same exception, it is reported once.
 
+"The same error" means the same exception class, raised from the same line, on
+the same controller action. So `/orders/1` and `/orders/2` failing the same way
+count as one error for `throttle_period`. At most 10 reports are delivered at
+once; during a storm, anything beyond that is dropped with a log line rather
+than starting more threads.
+
 Asynchronous deliveries still in flight are waited for at process exit, so a
 report from a rake task or `rails runner` is not lost when the process ends. Call
 `RailsDiscordNotifier.notifier.flush` to wait for them explicitly.

data/lib/generators/rails_discord_notifier/templates/rails_discord_notifier.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 RailsDiscordNotifier.configure do |config|
-  # Required. Must be an https://discord.com/api/webhooks/... URL.
-  # If it is missing or malformed the notifier stays disabled and logs a warning
-  # rather than breaking boot.
-  config.webhook_url = ENV.fetch("DISCORD_WEBHOOK_URL", nil)
-
-  # Appearance of the bot in Discord.
+  # Required. A Discord (https://discord.com/api/webhooks/...) or Google Chat
+  # (https://chat.googleapis.com/v1/spaces/...) webhook URL. The message format
+  # follows the URL. If it is missing or malformed the notifier stays disabled and
+  # logs a warning rather than breaking boot. Keep it out of source control.
+  config.webhook_url = ENV.fetch("DISCORD_WEBHOOK_URL", nil).presence || ENV.fetch("GOOGLE_CHAT_WEBHOOK_URL", nil)
+
+  # Appearance of the bot in Discord. Google Chat uses the name and avatar set on
+  # the webhook itself.
   config.username = ENV.fetch("ERROR_BOT_NAME", "Error Bot")
   # config.avatar_url = ENV.fetch("ERROR_BOT_AVATAR_URL", nil)
 
@@ -20,7 +22,7 @@ RailsDiscordNotifier.configure do |config|
   # Collapse repeats of the same error for this many seconds. 0 disables it.
   # config.throttle_period = 60
 
-  # Network timeouts, in seconds. Kept short so a slow Discord never slows you down.
+  # Network timeouts, in seconds. Kept short so a slow webhook never slows you down.
   # config.open_timeout  = 2
   # config.read_timeout  = 5
   # config.write_timeout = 5

data/lib/rails_discord_notifier/cli.rb

@@ -2,19 +2,20 @@
 
 module RailsDiscordNotifier
   # `rails_discord_notifier test` posts a real message to your webhook and prints
-  # what Discord said. It answers the first question every user of this gem has:
+  # what the service said. It answers the first question every user of this gem has:
   # "is my webhook actually wired up?"
   class CLI
     USAGE = <<~TEXT
       Usage: rails_discord_notifier <command> [options]
 
       Commands:
-        test       Send a sample exception report to your Discord webhook
+        test       Send a sample exception report to your Discord or Google Chat webhook
         version    Print the gem version
         help       Show this message
 
       Options:
-        --webhook URL   Webhook to use (defaults to $DISCORD_WEBHOOK_URL)
+        --webhook URL   Webhook to use (defaults to $DISCORD_WEBHOOK_URL,
+                        then $GOOGLE_CHAT_WEBHOOK_URL)
     TEXT
 
     def initialize(argv, out: $stdout, env: ENV)
@@ -42,16 +43,16 @@ module RailsDiscordNotifier
         return 1
       end
 
-      @out.puts("Posting a sample exception report to Discord…")
+      @out.puts("Posting a sample exception report to your webhook…")
       deliver(config)
     end
 
     def deliver(config)
       if Client.new(config).post(sample_payload(config))
-        @out.puts("Sent. Check your Discord channel.")
+        @out.puts("Sent. Check your channel.")
         0
       else
-        @out.puts("Discord did not accept the message. See the logged response above.")
+        @out.puts("The webhook did not accept the message. See the logged response above.")
         1
       end
     end
@@ -62,7 +63,7 @@ module RailsDiscordNotifier
       rescue StandardError => e
         e
       end
-      Payload.new(exception, config: config).to_h
+      Payload.build(exception, config: config).to_h
     end
 
     def test_config
@@ -78,14 +79,17 @@ module RailsDiscordNotifier
       index = @argv.index("--webhook")
       return @argv[index + 1] if index && @argv[index + 1]
 
-      @env["DISCORD_WEBHOOK_URL"]
+      # Blank counts as unset: deploy templates often export unused variables as "".
+      @env.values_at("DISCORD_WEBHOOK_URL", "GOOGLE_CHAT_WEBHOOK_URL").find { |url| !url.to_s.strip.empty? }
     end
 
+    # Never echoes the URL: it is a credential and this may be a CI log.
     def webhook_help
       if webhook_url.to_s.strip.empty?
-        "No webhook configured. Set DISCORD_WEBHOOK_URL or pass --webhook URL."
+        "No webhook configured. Set DISCORD_WEBHOOK_URL or GOOGLE_CHAT_WEBHOOK_URL, or pass --webhook URL."
       else
-        "Invalid webhook: expected an https://discord.com/api/webhooks/... URL, got #{webhook_url}"
+        "Invalid webhook: expected an https://discord.com/api/webhooks/... " \
+          "or https://chat.googleapis.com/v1/spaces/... URL"
       end
     end
 

data/lib/rails_discord_notifier/client.rb

@@ -5,7 +5,7 @@ require "net/http"
 require "uri"
 
 module RailsDiscordNotifier
-  # Posts a prepared payload to the Discord webhook.
+  # Posts a prepared payload to the configured webhook.
   #
   # Never raises: a notifier that breaks the request it is reporting on is worse
   # than no notifier. Every failure is logged and swallowed.
@@ -16,7 +16,7 @@ module RailsDiscordNotifier
       @config = config
     end
 
-    # Returns true when Discord accepted the message.
+    # Returns true when the service accepted the message.
     def post(payload)
       uri = target_uri
       return false if uri.nil?
@@ -54,17 +54,17 @@ module RailsDiscordNotifier
       end
     end
 
-    # Logs whatever Discord said, and answers whether the message got through.
+    # Logs whatever the service said, and answers whether the message got through.
     def accepted?(response)
       return true if SUCCESS.cover?(response.code.to_i)
 
       if response.code.to_i == 429
         config.logger.warn(
-          "[RailsDiscordNotifier] rate limited by Discord, retry after #{response["Retry-After"] || "unknown"}s"
+          "[RailsDiscordNotifier] rate limited by the webhook, retry after #{response["Retry-After"] || "unknown"}s"
         )
       else
         config.logger.error(
-          "[RailsDiscordNotifier] Discord rejected the message: HTTP #{response.code} #{response.body}"
+          "[RailsDiscordNotifier] webhook rejected the message: HTTP #{response.code} #{response.body}"
         )
       end
       false

data/lib/rails_discord_notifier/configuration.rb

@@ -12,6 +12,9 @@ module RailsDiscordNotifier
     # misconfiguration or an attempt to point the notifier at a third party.
     WEBHOOK_HOSTS = %w[discord.com discordapp.com].freeze
 
+    # Google Chat incoming webhooks live on this one host, never a subdomain.
+    GOOGLE_CHAT_HOST = "chat.googleapis.com"
+
     # Noisy, client-caused exceptions that almost always mean "bad request",
     # not "bug worth waking someone for".
     DEFAULT_IGNORED_EXCEPTIONS = %w[
@@ -74,7 +77,7 @@ module RailsDiscordNotifier
       @enabled.nil? ? default_enabled? : @enabled
     end
 
-    # True only when the notifier should actually talk to Discord.
+    # True only when the notifier should actually talk to the webhook.
     def enabled?
       !!enabled && valid_webhook_url?
     end
@@ -83,7 +86,12 @@ module RailsDiscordNotifier
       uri = parsed_webhook_url
       return false if uri.nil?
 
-      uri.scheme == "https" && discord_host?(uri.host)
+      uri.scheme == "https" && (discord_host?(uri.host) || google_chat_host?(uri.host))
+    end
+
+    # Decides the message format: Google Chat, or Discord for everything else.
+    def google_chat?
+      google_chat_host?(parsed_webhook_url&.host)
     end
 
     def ignore?(exception)
@@ -123,6 +131,10 @@ module RailsDiscordNotifier
       WEBHOOK_HOSTS.any? { |allowed| host == allowed || host.end_with?(".#{allowed}") }
     end
 
+    def google_chat_host?(host)
+      host.to_s.downcase == GOOGLE_CHAT_HOST
+    end
+
     def default_enabled?
       !NON_REPORTING_ENVIRONMENTS.include?(environment.to_s)
     end

data/lib/rails_discord_notifier/error_subscriber.rb

@@ -28,7 +28,8 @@ module RailsDiscordNotifier
     def extra_fields(handled, severity, source, context)
       fields = { "Severity" => severity.to_s, "Handled" => handled.to_s }
       fields["Source"] = source.to_s if source
-      context.except(:env, "env").each { |key, value| fields[key.to_s] = value.to_s }
+      # Left as-is: the payload filters nested values, then stringifies them.
+      context.except(:env, "env").each { |key, value| fields[key.to_s] = value }
       fields
     end
 

data/lib/rails_discord_notifier/google_chat_payload.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RailsDiscordNotifier
+  # Turns an exception (plus optional Rack env) into a Google Chat webhook body.
+  #
+  # Gathers, redacts and budgets exactly what the Discord payload does, then
+  # renders it as one plain-text message. Discord's 6000 character embed budget
+  # keeps the result far below Google Chat's 32,000 byte message limit.
+  class GoogleChatPayload < Payload
+    CODE_FENCE = "```"
+    CODE_BLOCK_OVERHEAD = "#{CODE_FENCE}\n\n#{CODE_FENCE}".length
+
+    # Chat renders "<users/all>" as an @all mention and "<url|text>" as a masked
+    # link. A zero-width space after every "<" defuses both without changing
+    # what the message looks like. The message itself never needs a "<".
+    MARKUP_OPENER = "<"
+    DEFUSED_OPENER = "<\u200B"
+
+    def to_h
+      @to_h ||= { text: render(embed).gsub(MARKUP_OPENER, DEFUSED_OPENER) }
+    end
+
+    private
+
+    def render(embed)
+      heading = [bold(embed[:title]), embed[:description], ""]
+      (heading + embed[:fields].map { |field| render_field(field) }).join("\n")
+    end
+
+    def render_field(field)
+      separator = field[:value].include?("\n") ? "\n" : " "
+      "#{bold("#{field[:name]}:")}#{separator}#{field[:value]}"
+    end
+
+    def bold(text)
+      "*#{text}*"
+    end
+
+    # Chat code blocks take no language tag; a "json" one would be shown as text.
+    def fence(text)
+      "#{CODE_FENCE}\n#{truncate(text, FIELD_VALUE_LIMIT - CODE_BLOCK_OVERHEAD)}\n#{CODE_FENCE}"
+    end
+
+    def formatted_backtrace
+      lines = Array(exception.backtrace).first(config.backtrace_lines)
+      return "No backtrace available" if lines.empty?
+
+      fence(lines.join("\n"))
+    end
+  end
+end

data/lib/rails_discord_notifier/notifier.rb

@@ -7,10 +7,14 @@ module RailsDiscordNotifier
   #
   # Delivery happens off the request thread by default, and repeats of the same
   # error are collapsed, so an error storm cannot slow the application down or
-  # bury the Discord channel.
+  # bury the channel.
   class Notifier
     MAX_TRACKED_FINGERPRINTS = 1_000
 
+    # Asynchronous deliveries allowed at once. Beyond this a report is dropped,
+    # so an error storm against a slow webhook cannot exhaust the host's threads.
+    MAX_IN_FLIGHT = 10
+
     # Stamped on an exception once it has been reported, so that the middleware
     # and the Rails.error subscriber cannot both announce the same failure.
     REPORTED_FLAG = :@__rails_discord_notifier_reported
@@ -37,16 +41,17 @@ module RailsDiscordNotifier
     end
 
     # Returns the delivery Thread when asynchronous, the client result when
-    # synchronous, and false when the exception was not reportable.
+    # synchronous, and false when the exception was not reportable or the report
+    # was dropped because MAX_IN_FLIGHT deliveries were already running.
     def notify(exception, env: nil, context: {})
       return false unless report?(exception)
       return false if already_reported?(exception)
 
       mark_reported(exception)
-      payload = Payload.new(exception, config: config, env: env, context: context)
+      payload = Payload.build(exception, config: config, env: env, context: context)
       return false if throttled?(payload.fingerprint)
 
-      deliver(payload.to_h)
+      deliver(payload.to_h, payload.fingerprint)
     rescue StandardError => e
       log_internal_failure(e)
       false
@@ -73,23 +78,31 @@ module RailsDiscordNotifier
       nil
     end
 
-    def deliver(body)
+    def deliver(body, fingerprint)
       return client.post(body) unless config.async
 
       register_flush_at_exit
-      track(Thread.new do
+      thread = @lock.synchronize do
+        @threads.select!(&:alive?)
+        if @threads.size >= MAX_IN_FLIGHT
+          @seen.delete(fingerprint) # never sent, so the next occurrence is not a repeat
+          next
+        end
+
+        (@threads << spawn_delivery(body)).last
+      end
+      return thread if thread
+
+      config.logger.warn("[RailsDiscordNotifier] report dropped: #{MAX_IN_FLIGHT} deliveries already in flight")
+      false
+    end
+
+    def spawn_delivery(body)
+      Thread.new do
         client.post(body)
       rescue StandardError => e
         log_internal_failure(e)
-      end)
-    end
-
-    def track(thread)
-      @lock.synchronize do
-        @threads.select!(&:alive?)
-        @threads << thread
       end
-      thread
     end
 
     def register_flush_at_exit

data/lib/rails_discord_notifier/payload.rb

@@ -34,6 +34,11 @@ module RailsDiscordNotifier
     DROP_ORDER = ["Params", "User Agent", "Host", "Request ID", "Release",
                   "Environment", "Action", "Controller", "URL"].freeze
 
+    # The payload for whichever service the configured webhook belongs to.
+    def self.build(exception, config:, **options)
+      (config.google_chat? ? GoogleChatPayload : Payload).new(exception, config: config, **options)
+    end
+
     def initialize(exception, config:, env: nil, context: {})
       @exception = exception
       @config    = config
@@ -46,15 +51,15 @@ module RailsDiscordNotifier
     end
 
     def size
-      embed = to_h[:embeds].first
-      embed[:title].to_s.length + embed[:description].to_s.length +
-        embed[:fields].sum { |f| f[:name].to_s.length + f[:value].to_s.length }
+      embed_size(embed)
     end
 
-    # Stable identity for an error occurrence, used to throttle repeats.
+    # Stable identity for an error occurrence, used to throttle repeats. Keyed on
+    # the route, not the path, so /users/1, /users/2 and /users/1.json are one
+    # error rather than a way around the throttle.
     def fingerprint
       @fingerprint ||= Digest::SHA256.hexdigest(
-        [exception.class.name, Array(exception.backtrace).first, location].join("|")
+        [exception.class.name, Array(exception.backtrace).first, *rails_params.values_at("controller", "action")].join("|")
       )
     end
 
@@ -63,7 +68,7 @@ module RailsDiscordNotifier
     attr_reader :exception, :config, :env, :context
 
     def embed
-      enforce_total_budget(
+      @embed ||= enforce_total_budget(
         {
           title: truncate(title, TITLE_LIMIT),
           description: truncate(description, DESCRIPTION_LIMIT),
@@ -74,22 +79,18 @@ module RailsDiscordNotifier
       )
     end
 
-    # Coarse "where did this happen" key: request path, or nothing outside a request.
-    def location
-      request ? "#{env["REQUEST_METHOD"]} #{request.path}" : nil
-    end
-
     def title
-      return exception.class.name unless request
-
-      "Exception in #{env["REQUEST_METHOD"]} #{request.path}"
+      request ? "Exception in #{env["REQUEST_METHOD"]} #{request.path}" : exception.class.name
     end
 
     def description
-      text = "**#{exception.class}**: #{scrubber.scrub(exception.message)}"
-      cause = exception.cause
-      text << "\nCaused by **#{cause.class}**: #{scrubber.scrub(cause.message)}" if cause
-      text
+      [exception, exception.cause].compact
+                                  .map { |error| "#{bold(error.class)}: #{scrubber.scrub(error.message)}" }
+                                  .join("\nCaused by ")
+    end
+
+    def bold(text)
+      "**#{text}**"
     end
 
     def scrubber
@@ -122,9 +123,16 @@ module RailsDiscordNotifier
       ]
     end
 
+    # ParameterFilter only walks into real Hashes, so ActionController::Parameters
+    # is unwrapped first. Context the filter cannot process is left out: sending
+    # it unfiltered could leak, and failing here would drop the whole report.
     def context_fields
       extra = context.merge(configured_context)
-      extra.map { |name, value| { name: name.to_s, value: value.to_s, inline: true } }
+                     .transform_values { |value| value.respond_to?(:to_unsafe_h) ? value.to_unsafe_h : value }
+      parameter_filter.filter(extra).map { |name, value| { name: name.to_s, value: value.to_s, inline: true } }
+    rescue StandardError => e
+      config.logger.warn("[RailsDiscordNotifier] context left out, the filter raised #{e.class}: #{e.message}")
+      []
     end
 
     def configured_context
@@ -263,7 +271,7 @@ module RailsDiscordNotifier
     end
 
     def truncate(string, limit)
-      string = string.to_s
+      string = SecretScrubber.utf8(string)
       return string if string.length <= limit
       return string[0, limit].to_s if limit < ELLIPSIS.length
 

data/lib/rails_discord_notifier/secret_scrubber.rb

@@ -6,27 +6,53 @@ module RailsDiscordNotifier
   # Exception messages cannot be filtered the way structured parameters can, so
   # this is deliberately a best effort: it catches the shapes credentials
   # actually take when they end up in a message - `token=abc`, `password="x"`,
-  # `Api_Key: abc` - and leaves ordinary prose ("password reset email") alone.
+  # `Api_Key: abc`, `"password":"x"`, `Authorization: Bearer abc`,
+  # `redis://:pw@host` - and leaves ordinary prose ("password reset email") alone.
   class SecretScrubber
+    KEY_CHAR = '[\w.\[\]-]'
+    # An optional closing quote on the key, then `=`, `:` or `=>`.
+    SEPARATOR = %q{(["']?\s*(?:=>|[=:])\s*)}
+    # A quoted string, an HTTP auth scheme with its credential, or one word.
+    VALUE = %q{(?:"[^"]*"|'[^']*'|(?:bearer|basic|token|digest|negotiate)\s+\S+|\S+)}
+    # Up to the last "@" before the host, so a raw "@" inside the password is covered too.
+    URL_PASSWORD = %r{(://[^:/@\s]*:)[^/\s]+(@)}
+
+    # Valid UTF-8, or JSON encoding fails and the report is lost. Binary (how Rack
+    # hands over headers) is read as UTF-8, other encodings are converted, and
+    # invalid bytes become U+FFFD either way.
+    def self.utf8(value)
+      string = value.to_s
+      string = string.dup.force_encoding(Encoding::UTF_8) if string.encoding == Encoding::BINARY
+      string.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).scrub
+    end
+
     def initialize(matchers)
       @matchers = matchers
     end
 
+    # Key patterns run first: URL_PASSWORD would otherwise read "host:8443?token=s3cr@"
+    # as a username and password, and swallow the key that marks the real secret.
     def scrub(text)
-      patterns.reduce(text.to_s) do |scrubbed, pattern|
-        scrubbed.gsub(pattern) { "#{Regexp.last_match(1)}#{Regexp.last_match(2)}[FILTERED]" }
+      scrubbed = patterns.reduce(self.class.utf8(text)) do |result, pattern|
+        result.gsub(pattern) { "#{Regexp.last_match(1)}#{Regexp.last_match(2)}[FILTERED]" }
       end
+      scrubbed.gsub(URL_PASSWORD) { "#{Regexp.last_match(1)}[FILTERED]#{Regexp.last_match(2)}" }
     end
 
     private
 
     # Regexp and Proc filters are skipped: they are written to match parameter
     # keys, not the inside of a sentence.
+    #
+    # A key may only start where a run of key characters starts, and is matched
+    # atomically. That keeps matching linear: before Ruby 3.2 the unanchored form
+    # took cubic time on input like "tokentoken…", stalling the whole process.
     def patterns
       @patterns ||= @matchers.filter_map do |matcher|
         next unless matcher.is_a?(String) || matcher.is_a?(Symbol)
 
-        /([\w.\[\]-]*#{Regexp.escape(matcher.to_s)}[\w.\[\]-]*)(\s*[=:]\s*)("[^"]*"|'[^']*'|\S+)/i
+        key = "(?<!#{KEY_CHAR})((?>#{KEY_CHAR}*?#{Regexp.escape(matcher.to_s)}#{KEY_CHAR}*+))"
+        /#{key}#{SEPARATOR}#{VALUE}/i
       end
     end
   end

data/lib/rails_discord_notifier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsDiscordNotifier
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/rails_discord_notifier.rb

@@ -4,6 +4,7 @@ require "rails_discord_notifier/version"
 require "rails_discord_notifier/configuration"
 require "rails_discord_notifier/secret_scrubber"
 require "rails_discord_notifier/payload"
+require "rails_discord_notifier/google_chat_payload"
 require "rails_discord_notifier/client"
 require "rails_discord_notifier/notifier"
 require "rails_discord_notifier/middleware"
@@ -66,7 +67,8 @@ module RailsDiscordNotifier
       return if !config.enabled || config.valid_webhook_url?
 
       config.logger.warn(
-        "[RailsDiscordNotifier] disabled: webhook_url must be an https://discord.com/api/webhooks/... URL"
+        "[RailsDiscordNotifier] disabled: webhook_url must be an https://discord.com/api/webhooks/... " \
+        "or https://chat.googleapis.com/v1/spaces/... URL"
       )
     end
   end

data/sig/rails_discord_notifier.rbs

@@ -32,6 +32,7 @@ module RailsDiscordNotifier
     def enabled: () -> bool
     def enabled?: () -> bool
     def valid_webhook_url?: () -> bool
+    def google_chat?: () -> bool
     def ignore?: (Exception) -> bool
     def logger: () -> untyped
     def environment: () -> String
@@ -39,12 +40,16 @@ module RailsDiscordNotifier
   end
 
   class Payload
+    def self.build: (Exception, config: Configuration, ?env: Hash[String, untyped]?, ?context: Hash[untyped, untyped]) -> Payload
     def initialize: (Exception, config: Configuration, ?env: Hash[String, untyped]?, ?context: Hash[untyped, untyped]) -> void
     def to_h: () -> Hash[Symbol, untyped]
     def size: () -> Integer
     def fingerprint: () -> String
   end
 
+  class GoogleChatPayload < Payload
+  end
+
   class Client
     def initialize: (Configuration) -> void
     def post: (Hash[Symbol, untyped]) -> bool

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_discord_notifier
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - GettinDrikkieWithIt
@@ -81,8 +81,8 @@ dependencies:
         version: '6.1'
 description: |
   RailsDiscordNotifier captures unhandled exceptions in your Rails application
-  and sends detailed error reports to a Discord channel using an incoming webhook.
-  Customize the bot username, avatar, and message format via initializer.
+  and sends detailed, redacted error reports to a Discord channel or a Google
+  Chat space using an incoming webhook.
 email:
 - 33983365+gettinDrikkieWithIt@users.noreply.github.com
 executables:
@@ -102,6 +102,7 @@ files:
 - lib/rails_discord_notifier/client.rb
 - lib/rails_discord_notifier/configuration.rb
 - lib/rails_discord_notifier/error_subscriber.rb
+- lib/rails_discord_notifier/google_chat_payload.rb
 - lib/rails_discord_notifier/middleware.rb
 - lib/rails_discord_notifier/notifier.rb
 - lib/rails_discord_notifier/payload.rb
@@ -134,5 +135,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Send Rails exceptions to Discord via configurable webhook
+summary: Send Rails exceptions to Discord or Google Chat via configurable webhook
 test_files: []