tg_error_notifier 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03b6d8e79dd258e7487a99925017dc62d9fd7d66255af5e80c62aecff7b6638b
-  data.tar.gz: 062f6f0253004feb248c55e9cf2962244a7683c6d6771dac55f9a762a1c97bec
+  metadata.gz: 71739ce66aa4580137b5c1781b0a6ae388713379297c26895883b77b4b8ba7a4
+  data.tar.gz: 0c0303ccbdc01d133029ee4ffcd842e7fc665223c804fd125bcdd82e1fb53761
 SHA512:
-  metadata.gz: 8caa97214339f4f0af2683a40f7d3a705a80fd0ecb9dd65f7a242d97efb38b2cab5e284b5b4f2d2cff3bb0121034190b09f8ad87793529937e89a2624bf1bc3c
-  data.tar.gz: 8e546d58081bd0e50abae5bf375a7d9adac0ada19032fb44fbfe089fedb62fbaf55e0abe4b35489857716fa21352466c90224d36592faa43926d6fd578330b5b
+  metadata.gz: 1dd5dd9a02ec60173ff81eeb6b30f84831b351d9ac12f07d4d6ead4e1fb22eee0cadefcffc7acf85638ba4e4e3aa344873091e111bb9ddd2f228f67f1bb652ee
+  data.tar.gz: 53f7ffc99e4672c9bbde0b52897a7da2c05ae5327bf69fcdfcacdbe6fdfb06038b36696d5fe691f5b50091393d7a1f4458099d52cb53f1f19ec924f70c948141

data/README.md

@@ -158,6 +158,19 @@ end
 
 Without a store everything still works, but each process creates its own topic. Named topics work independently of `topics_enabled` (which controls per-exception topics). Requirements are the same: forum supergroup + `can_manage_topics` bot permission.
 
+## Filtering request data
+
+The query string of a failed request is filtered with `Rails.application.config.filter_parameters` (the same rules as the Rails log) before it is sent: `?token=abc` arrives as `?token=[FILTERED]`. A query that cannot be parsed is not sent at all. Override the rules with `config.filter_parameters = [...]`.
+
+Paths that carry a secret as a segment (one-time login links, invitations) are masked by prefix:
+
+```ruby
+TgErrorNotifier.configure do |config|
+  config.sensitive_path_prefixes = %w[/tsd/ /invitations/]
+end
+# "/tsd/abc123/scan" is reported as "/tsd/[FILTERED]/scan"
+```
+
 ## Buttons under the message
 
 Attach an inline keyboard to error notifications — e.g. a link that files the error as a task on your board. The gem does not interpret the buttons: whatever the callable returns is passed to Telegram as is, so `url`, `callback_data` and `web_app` buttons all work.
@@ -185,3 +198,35 @@ Arguments:
 | `fingerprint` | grouping key of the exception — stable across repeats, use it to deduplicate whatever the button creates (nil for `:message`) |
 
 Return an array of rows (`[[button, button], [button]]`); a flat array becomes a single row; `nil` or `[]` means no keyboard. Exceptions raised inside the callable are logged and the notification is still delivered — without the keyboard.
+
+## Updating buttons later
+
+`notify`, `capture_exception` and `capture_message` return the ids of the delivered message:
+
+```ruby
+result = TgErrorNotifier.capture_exception(error)
+# => { sent: true, status: :sent, code: 200, message_id: 812, chat_id: -1001234567890, thread_id: 15 }
+```
+
+Keep them if the notification should reflect what happened next — e.g. replace "To the board" with a link to the task once it exists:
+
+```ruby
+TgErrorNotifier.edit_buttons(
+  chat_id: stored.chat_id,
+  message_id: stored.message_id,
+  buttons: [[{ text: "Task #42 · In progress", url: "https://example.com/tasks/42" }]]
+)
+```
+
+`buttons` takes rows in the same shape as `config.buttons`; `nil` or `[]` removes the keyboard. Only the keyboard changes, the text stays as it was. The result is a hash with `status`:
+
+| status | meaning |
+| --- | --- |
+| `:edited` | keyboard replaced |
+| `:not_modified` | keyboard is already the same |
+| `:not_found` | the message was deleted — forget its ids |
+| `:rate_limited` | Telegram asked to wait `retry_after` seconds |
+| `:skipped` | notifier is disabled in this environment |
+| `:failed` | any other API error, with `code` and `body` |
+
+Unlike notifications, which never raise, `edit_buttons` lets network errors through: it is called by your code (usually a background job), which knows whether to retry. Telegram allows roughly 20 edits per minute in a group, so update the latest few messages of an error, not all of them.

data/lib/tg_error_notifier/configuration.rb

@@ -26,7 +26,9 @@ module TgErrorNotifier
       :topic_icon_color,
       :topic_store_read,
       :topic_store_write,
-      :buttons
+      :buttons,
+      :filter_parameters,
+      :sensitive_path_prefixes
 
     def initialize
       @enabled = true
@@ -74,6 +76,15 @@ module TgErrorNotifier
       # Return nil or [] for no keyboard. Errors raised inside are logged and
       # the message is still delivered, without the keyboard.
       @buttons = nil
+      # Query string of a failed request is filtered before it leaves the app:
+      # tokens in links (?token=..., ?code=...) must not end up in a Telegram chat.
+      # nil means "use Rails.application.config.filter_parameters" — the same
+      # rules as the Rails log.
+      @filter_parameters = nil
+      # Paths whose next segment is a secret (one-time login links and the like):
+      #   config.sensitive_path_prefixes = %w[/tsd/ /invitations/]
+      # "/tsd/abc123/x" is reported as "/tsd/[FILTERED]/x".
+      @sensitive_path_prefixes = []
     end
 
     def proxy?

data/lib/tg_error_notifier/middleware.rb

@@ -2,6 +2,8 @@
 
 module TgErrorNotifier
   class Middleware
+    FILTERED = "[FILTERED]"
+
     def initialize(app)
       @app = app
     end
@@ -14,12 +16,41 @@ module TgErrorNotifier
         source: "rack",
         context: {
           method: env["REQUEST_METHOD"],
-          path: env["PATH_INFO"],
-          query: env["QUERY_STRING"],
+          path: self.class.filter_path(env["PATH_INFO"]),
+          query: self.class.filter_query(env["QUERY_STRING"]),
           request_id: env["action_dispatch.request_id"]
         }
       )
       raise
     end
+
+    class << self
+      def filter_query(query)
+        return query if query.nil? || query.empty?
+
+        params = Rack::Utils.parse_nested_query(query)
+        Rack::Utils.build_nested_query(parameter_filter.filter(params))
+                  .gsub(Rack::Utils.escape(FILTERED), FILTERED)
+      rescue StandardError
+        # Unparseable query (invalid encoding, broken nesting): it cannot be
+        # filtered key by key, so it is not reported at all.
+        FILTERED
+      end
+
+      def filter_path(path)
+        return path if path.nil? || path.empty?
+
+        TgErrorNotifier.configuration.sensitive_path_prefixes.reduce(path) do |result, prefix|
+          result.gsub(%r{(#{Regexp.escape(prefix)})[^/?]+}) { "#{Regexp.last_match(1)}#{FILTERED}" }
+        end
+      end
+
+      private
+
+      def parameter_filter
+        filters = TgErrorNotifier.configuration.filter_parameters || Rails.application.config.filter_parameters
+        ActiveSupport::ParameterFilter.new(filters, mask: FILTERED)
+      end
+    end
   end
 end

data/lib/tg_error_notifier/notifier.rb

@@ -90,6 +90,27 @@ module TgErrorNotifier
       { sent: false, status: :failed, reason: e.class.name, error: e.message }
     end
 
+    # Replaces the inline keyboard of an already delivered notification —
+    # e.g. "To the board" becomes "Task #42 · In progress" once somebody picks
+    # the error up. Message ids come from the notify/capture_* result.
+    # buttons: rows as in config.buttons; nil or [] removes the keyboard.
+    #
+    # Returns { edited: true, status: :edited } or { edited: false, status: }
+    # where status is :not_modified (keyboard is already the same),
+    # :not_found (message was deleted), :rate_limited (with retry_after
+    # seconds), :skipped or :failed. Network errors are raised: unlike a
+    # notification, an edit is called by the host, which decides whether to retry.
+    def edit_buttons(chat_id:, message_id:, buttons:)
+      enabled_check = enabled_status
+      return { edited: false, status: :skipped, reason: enabled_check[:reason] } unless enabled_check[:enabled]
+
+      payload = { chat_id: chat_id, message_id: message_id }
+      keyboard = keyboard_from(buttons)
+      payload[:reply_markup] = keyboard if keyboard
+
+      edit_result(post_api("editMessageReplyMarkup", payload))
+    end
+
     private
 
     attr_reader :config
@@ -122,8 +143,43 @@ module TgErrorNotifier
     end
 
     def send_payload(payload, retry_plain: true)
+      response = post_api("sendMessage", payload)
+      if response.is_a?(Net::HTTPSuccess)
+        return { sent: true, status: :sent, code: response.code.to_i }.merge(sent_message_ids(response))
+      end
+
+      log("telegram api error: HTTP #{response.code} #{response.body}")
+
+      # Последний рубеж: разметка не распарсилась — шлём то же самое
+      # обычным текстом, чтобы тело сообщения дошло в любом случае
+      if retry_plain && parse_entities_error?(response)
+        plain = payload.dup
+        plain.delete(:parse_mode)
+        plain[:text] = truncate(strip_html(payload[:text]))
+        return send_payload(plain, retry_plain: false)
+      end
+
+      { sent: false, status: :failed, reason: "telegram_api_error", code: response.code.to_i, body: response.body.to_s }
+    end
+
+    # Ids of the delivered message, so the host can edit it later
+    # (TgErrorNotifier.edit_buttons). A success response that cannot be read
+    # still means the message was delivered: report it as sent, without ids.
+    def sent_message_ids(response)
+      result = JSON.parse(response.body.to_s).fetch("result")
+      {
+        message_id: result.fetch("message_id"),
+        chat_id: result.fetch("chat").fetch("id"),
+        thread_id: result["message_thread_id"]
+      }
+    rescue JSON::ParserError, KeyError, TypeError, NoMethodError => e
+      log("sendMessage response without message ids: #{e.class}: #{e.message}")
+      {}
+    end
+
+    def post_api(method_name, payload)
       token = resolve(config.bot_token)
-      uri = URI("#{resolve(config.api_base)}/bot#{token}/sendMessage")
+      uri = URI("#{resolve(config.api_base)}/bot#{token}/#{method_name}")
 
       request = Net::HTTP::Post.new(uri)
       request["Content-Type"] = "application/json"
@@ -138,23 +194,35 @@ module TgErrorNotifier
       http.open_timeout = config.open_timeout
       http.read_timeout = config.read_timeout
 
-      response = http.request(request)
-      if response.is_a?(Net::HTTPSuccess)
-        return { sent: true, status: :sent, code: response.code.to_i }
-      end
+      http.request(request)
+    end
 
-      log("telegram api error: HTTP #{response.code} #{response.body}")
+    def edit_result(response)
+      return { edited: true, status: :edited } if response.is_a?(Net::HTTPSuccess)
 
-      # Последний рубеж: разметка не распарсилась — шлём то же самое
-      # обычным текстом, чтобы тело сообщения дошло в любом случае
-      if retry_plain && parse_entities_error?(response)
-        plain = payload.dup
-        plain.delete(:parse_mode)
-        plain[:text] = truncate(strip_html(payload[:text]))
-        return send_payload(plain, retry_plain: false)
+      body = response.body.to_s
+      description = begin
+        JSON.parse(body)["description"].to_s
+      rescue JSON::ParserError
+        body
       end
 
-      { sent: false, status: :failed, reason: "telegram_api_error", code: response.code.to_i, body: response.body.to_s }
+      if response.code.to_i == 400 && description.include?("message is not modified")
+        { edited: false, status: :not_modified }
+      elsif response.code.to_i == 400 && description.include?("message to edit not found")
+        { edited: false, status: :not_found }
+      elsif response.code.to_i == 429
+        { edited: false, status: :rate_limited, retry_after: retry_after(body) }
+      else
+        log("telegram api error on edit: HTTP #{response.code} #{body}")
+        { edited: false, status: :failed, code: response.code.to_i, body: body }
+      end
+    end
+
+    def retry_after(body)
+      JSON.parse(body).dig("parameters", "retry_after")
+    rescue JSON::ParserError
+      nil
     end
 
     def parse_entities_error?(response)
@@ -222,15 +290,19 @@ module TgErrorNotifier
         context: context,
         fingerprint: fingerprint
       )
+      keyboard_from(rows)
+    rescue StandardError => e
+      log("buttons failed: #{e.class}: #{e.message}")
+      nil
+    end
+
+    def keyboard_from(rows)
       return nil if rows.nil? || rows.empty?
 
       # Плоский список кнопок принимаем как одну строку клавиатуры.
       rows = [rows] unless rows.first.is_a?(Array)
 
       { inline_keyboard: rows }
-    rescue StandardError => e
-      log("buttons failed: #{e.class}: #{e.message}")
-      nil
     end
 
     def context_block(context)

data/lib/tg_error_notifier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TgErrorNotifier
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/tg_error_notifier.rb

@@ -36,6 +36,12 @@ module TgErrorNotifier
       notifier.notify_message(message: message, level: level, source: source, context: context, topic: topic)
     end
 
+    # Replace the buttons under a delivered notification. Ids come from the
+    # result of notify/capture_exception/capture_message (message_id, chat_id).
+    def edit_buttons(chat_id:, message_id:, buttons:)
+      notifier.edit_buttons(chat_id: chat_id, message_id: message_id, buttons: buttons)
+    end
+
     def reset!
       @configuration = nil
       @notifier = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tg_error_notifier
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Sergei Ustinov