tg_error_notifier 0.1.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 785aa28f5a62476e0f827430090ff0dad300edd8277b54672b88f3b89a7ee730
-  data.tar.gz: 680dea5d7f8440e07b41e5df415483e35a0aed5b8adbf0b5f9169302c1306422
+  metadata.gz: 03b6d8e79dd258e7487a99925017dc62d9fd7d66255af5e80c62aecff7b6638b
+  data.tar.gz: 062f6f0253004feb248c55e9cf2962244a7683c6d6771dac55f9a762a1c97bec
 SHA512:
-  metadata.gz: 001f1b8fb2fb679ea77acb1d1761f6fe67f3736b08be8be1fa5c9541e45818b137a37b9c39ea4ce7d59ede8cc654bdd9689be76959a4364253add6fccb4b0535
-  data.tar.gz: 58ccd0356a6699a0fafff07bd90d461a8a3654db0d00813faa5a3fc7b826593f737924756127fa809d7bf1be65eb1420460b7731cb9cf46349d19160f10291cc
+  metadata.gz: 8caa97214339f4f0af2683a40f7d3a705a80fd0ecb9dd65f7a242d97efb38b2cab5e284b5b4f2d2cff3bb0121034190b09f8ad87793529937e89a2624bf1bc3c
+  data.tar.gz: 8e546d58081bd0e50abae5bf375a7d9adac0ada19032fb44fbfe089fedb62fbaf55e0abe4b35489857716fa21352466c90224d36592faa43926d6fd578330b5b

data/README.md

@@ -70,6 +70,42 @@ Examples:
 - Ensure bot has permission to send messages.
 - Put value into `TELEGRAM_ERRORS_CHAT_ID` and run a smoke test.
 
+## Error grouping
+
+Group identical errors to avoid flooding. When the same exception repeats within a time window, only the first message is sent — subsequent occurrences are suppressed and reported as a count in the next message.
+
+```ruby
+TgErrorNotifier.configure do |config|
+  config.grouping_enabled = true
+  config.grouping_window = 60 # seconds (default)
+end
+```
+
+Errors are grouped by exception class + normalized message (IDs and UUIDs are replaced with placeholders for better deduplication).
+
+## Forum topics (threads)
+
+Automatically create a Telegram Forum topic (thread) per unique error type. Each error gets its own topic in a supergroup with Forum Topics enabled.
+
+```ruby
+TgErrorNotifier.configure do |config|
+  config.topics_enabled = true
+  config.topic_icon_color = 0xFB6F5F # red (default), optional
+end
+```
+
+**Requirements:** The chat must be a supergroup with Forum Topics enabled. The bot must have `can_manage_topics` admin permission.
+
+You can combine both features — errors will be grouped within their respective topics:
+
+```ruby
+TgErrorNotifier.configure do |config|
+  config.grouping_enabled = true
+  config.grouping_window = 60
+  config.topics_enabled = true
+end
+```
+
 ## Manual notification
 ```ruby
 begin
@@ -102,3 +138,50 @@ TgErrorNotifier.capture_message(
 ```
 
 `capture_message` returns the same diagnostic hash format as `capture_exception`.
+
+## Named topics for messages
+
+Send messages to a dedicated Forum topic by name. The topic is created on first use (blue icon) and reused afterwards:
+
+```ruby
+TgErrorNotifier.capture_message("New account: #{account.name}", topic: "Registrations")
+```
+
+Since the topic → thread_id mapping is cached in memory per process, configure a persistent store so restarts and multiple processes (Puma workers, Sidekiq) don't create duplicate topics:
+
+```ruby
+TgErrorNotifier.configure do |config|
+  config.topic_store_read  = ->(name) { MyKeyValueStore.get("tg_topic:#{name}") }
+  config.topic_store_write = ->(name, thread_id) { MyKeyValueStore.set("tg_topic:#{name}", thread_id) }
+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.
+
+## 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.
+
+```ruby
+TgErrorNotifier.configure do |config|
+  config.buttons = lambda do |kind:, source:, context:, fingerprint:, exception: nil, message: nil|
+    next nil unless kind == :exception
+
+    token = ErrorTaskLink.issue(exception: exception, source: source, fingerprint: fingerprint)
+    [[{ text: "\u2795 To the board", url: "https://example.com/e/#{token}" }]]
+  end
+end
+```
+
+Arguments:
+
+| key | value |
+| --- | --- |
+| `kind` | `:exception` for `capture_exception`/rescued errors, `:message` for `capture_message` |
+| `exception` | the exception (nil for `:message`) |
+| `message` | the message text (nil for `:exception`) |
+| `source` | where it came from (`"Sidekiq: MyWorker"`, `"manual"`, ...) |
+| `context` | the context hash passed to the notifier |
+| `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.

data/lib/tg_error_notifier/configuration.rb

@@ -19,7 +19,14 @@ module TgErrorNotifier
       :proxy_addr,
       :proxy_port,
       :proxy_user,
-      :proxy_pass
+      :proxy_pass,
+      :grouping_enabled,
+      :grouping_window,
+      :topics_enabled,
+      :topic_icon_color,
+      :topic_store_read,
+      :topic_store_write,
+      :buttons
 
     def initialize
       @enabled = true
@@ -44,6 +51,29 @@ module TgErrorNotifier
       @proxy_port = nil
       @proxy_user = nil
       @proxy_pass = nil
+      @grouping_enabled = false
+      @grouping_window = 60
+      @topics_enabled = false
+      @topic_icon_color = nil
+      # Persistent storage for named topics (created via capture_message topic:).
+      # Without a store each process/restart would create a duplicate forum topic.
+      #   topic_store_read  = ->(name) { ... }        # returns thread_id or nil
+      #   topic_store_write = ->(name, thread_id) { ... }
+      @topic_store_read = nil
+      @topic_store_write = nil
+      # Inline keyboard attached under the message. The gem does not interpret
+      # the buttons: whatever the host returns goes to Telegram as is, so the
+      # host is free to use url buttons, callback_data or web_app.
+      #
+      #   config.buttons = lambda do |kind:, source:, context:, fingerprint:, exception: nil, message: nil|
+      #     [[{ text: "To the board", url: "https://example.com/e/#{token}" }]]
+      #   end
+      #
+      # Return value: array of rows, each row an array of button hashes.
+      # A flat array of buttons is accepted too and becomes a single row.
+      # Return nil or [] for no keyboard. Errors raised inside are logged and
+      # the message is still delivered, without the keyboard.
+      @buttons = nil
     end
 
     def proxy?

data/lib/tg_error_notifier/grouper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module TgErrorNotifier
+  class Grouper
+    Entry = Struct.new(:count, :first_at, :last_sent_at, :thread_id, keyword_init: true)
+
+    CLEANUP_INTERVAL = 100
+
+    def initialize(window:)
+      @window = window
+      @mutex = Mutex.new
+      @entries = {}
+      @call_count = 0
+    end
+
+    # Returns:
+    #   { action: :send, count: N, thread_id: id_or_nil }
+    #   { action: :suppress }
+    def process(key:, thread_id: nil)
+      now = Time.now
+
+      @mutex.synchronize do
+        @call_count += 1
+        lazy_cleanup!(now) if (@call_count % CLEANUP_INTERVAL).zero?
+
+        entry = @entries[key]
+
+        if entry.nil?
+          @entries[key] = Entry.new(count: 0, first_at: now, last_sent_at: now, thread_id: thread_id)
+          return { action: :send, count: 0, thread_id: thread_id }
+        end
+
+        entry.thread_id = thread_id if entry.thread_id.nil? && thread_id
+
+        elapsed = now - entry.last_sent_at
+
+        if elapsed >= @window
+          accumulated = entry.count
+          entry.count = 0
+          entry.last_sent_at = now
+          { action: :send, count: accumulated, thread_id: entry.thread_id }
+        else
+          entry.count += 1
+          { action: :suppress }
+        end
+      end
+    end
+
+    def rollback(key)
+      @mutex.synchronize do
+        @entries.delete(key)
+      end
+    end
+
+    def grouping_key(exception)
+      "#{exception.class.name}:#{normalize_message(exception.message)}"
+    end
+
+    private
+
+    def normalize_message(message)
+      msg = message.to_s
+      msg = msg.gsub(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i, "<UUID>")
+      msg = msg.gsub(/\b\d{4,}\b/, "<ID>")
+      msg = msg.gsub(/#<\w+:0x[0-9a-f]+>/i, "#<Object>")
+      msg.strip
+    end
+
+    def lazy_cleanup!(now)
+      cutoff = now - 3600
+      @entries.delete_if { |_, e| e.last_sent_at < cutoff }
+    end
+  end
+end

data/lib/tg_error_notifier/notifier.rb

@@ -7,6 +7,10 @@ require "cgi"
 module TgErrorNotifier
   class Notifier
     MAX_MESSAGE_LENGTH = 3800
+    # Отдельные поля (сообщение исключения, значения контекста) режем заранее,
+    # чтобы гарантированно осталось место под бэктрейс и закрывающие теги
+    MAX_FIELD_LENGTH = 900
+    HTML_TAGS = %w[pre code b i u s].freeze
 
     def initialize(config)
       @config = config
@@ -23,21 +27,63 @@ module TgErrorNotifier
         return { sent: false, status: :skipped, reason: "ignored_exception" }
       end
 
-      payload = build_payload(exception: exception, source: source, context: context)
-      send_payload(payload)
+      key = nil
+      thread_id = nil
+      suppressed_count = 0
+
+      if config.topics_enabled || config.grouping_enabled || config.buttons
+        key = grouper.grouping_key(exception)
+      end
+
+      if config.topics_enabled
+        thread_id = topic_manager.thread_id_for(key, exception)
+      end
+
+      if config.grouping_enabled
+        result = grouper.process(key: key, thread_id: thread_id)
+        if result[:action] == :suppress
+          return { sent: false, status: :suppressed }
+        end
+        suppressed_count = result[:count]
+        thread_id = result[:thread_id] || thread_id
+      end
+
+      payload = build_payload(
+        exception: exception,
+        source: source,
+        context: context,
+        thread_id: thread_id,
+        suppressed_count: suppressed_count,
+        fingerprint: key
+      )
+      response = send_payload(payload)
+
+      if !response[:sent] && config.grouping_enabled && key
+        grouper.rollback(key)
+      end
+
+      response
     rescue StandardError => e
       log("notify failed: #{e.class}: #{e.message}")
       { sent: false, status: :failed, reason: e.class.name, error: e.message }
     end
 
-    def notify_message(message:, level:, source:, context: {})
+    def notify_message(message:, level:, source:, context: {}, topic: nil, thread_id: nil)
       enabled_check = enabled_status
       unless enabled_check[:enabled]
         log("skipped: #{enabled_check[:reason]}")
         return { sent: false, status: :skipped, reason: enabled_check[:reason] }
       end
 
-      payload = build_message_payload(message: message, level: level, source: source, context: context)
+      thread_id ||= topic_manager.thread_id_for_name(topic) if topic
+
+      payload = build_message_payload(
+        message: message,
+        level: level,
+        source: source,
+        context: context,
+        thread_id: thread_id
+      )
       send_payload(payload)
     rescue StandardError => e
       log("notify_message failed: #{e.class}: #{e.message}")
@@ -48,6 +94,14 @@ module TgErrorNotifier
 
     attr_reader :config
 
+    def grouper
+      @grouper ||= Grouper.new(window: config.grouping_window)
+    end
+
+    def topic_manager
+      @topic_manager ||= TopicManager.new(config)
+    end
+
     def enabled_status
       return { enabled: false, reason: "disabled" } unless resolve(config.enabled)
       if config.ignored_environments.include?(resolve(config.environment).to_s)
@@ -67,7 +121,7 @@ module TgErrorNotifier
       ignored.include?(exception.class.name)
     end
 
-    def send_payload(payload)
+    def send_payload(payload, retry_plain: true)
       token = resolve(config.bot_token)
       uri = URI("#{resolve(config.api_base)}/bot#{token}/sendMessage")
 
@@ -90,40 +144,103 @@ module TgErrorNotifier
       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
 
-    def build_payload(exception:, source:, context: {})
-      text = [
+    def parse_entities_error?(response)
+      response.code.to_i == 400 && response.body.to_s.include?("can't parse entities")
+    end
+
+    def build_payload(exception:, source:, context: {}, thread_id: nil, suppressed_count: 0, fingerprint: nil)
+      parts = [
         "<b>🚨 #{escape(resolve(config.app_name).to_s)}: #{escape(resolve(config.environment).to_s)}</b>",
-        "<b>Source:</b> #{escape(source.to_s)}",
+        "<b>Source:</b> #{escape(clamp(source, MAX_FIELD_LENGTH))}",
         "<b>Exception:</b> <code>#{escape(exception.class.name)}</code>",
-        "<b>Message:</b> #{escape(exception.message.to_s)}",
-        context_block(context)
-      ].compact.join("\n")
+        "<b>Message:</b> #{escape(clamp(exception.message, MAX_FIELD_LENGTH))}"
+      ]
+
+      if suppressed_count > 0
+        parts << "<b>🔁 +#{suppressed_count} more in last #{config.grouping_window}s</b>"
+      end
+
+      parts << context_block(context)
+
+      text = truncate(parts.compact.join("\n"))
 
       if config.include_backtrace && exception.backtrace
         lines = exception.backtrace.first(config.max_backtrace_lines)
-        bt = escape(lines.join("\n"))
-        text = "#{text}\n<b>Backtrace:</b>\n<pre>#{bt}</pre>"
+        header = "\n<b>Backtrace:</b>\n"
+        # Бэктрейс режем по остатку бюджета ДО оборачивания в <pre>,
+        # иначе финальный truncate обрезал бы текст внутри тега и Telegram
+        # отвечал 400 "can't find end tag corresponding to start tag pre"
+        budget = MAX_MESSAGE_LENGTH - text.length - header.length - "<pre></pre>".length
+        if budget > 100
+          bt = cut_escaped(escape(lines.join("\n")), budget)
+          text = "#{text}#{header}<pre>#{bt}</pre>"
+        end
       end
 
-      {
+      payload = {
         chat_id: resolve(config.chat_id),
         text: truncate(text),
         parse_mode: "HTML",
         disable_web_page_preview: true
       }
+      payload[:message_thread_id] = thread_id if thread_id
+      keyboard = build_keyboard(
+        kind: :exception,
+        exception: exception,
+        source: source,
+        context: context,
+        fingerprint: fingerprint
+      )
+      payload[:reply_markup] = keyboard if keyboard
+      payload
+    end
+
+    # Кнопки строит хост (config.buttons) — гем не знает, куда они ведут.
+    # Сбой в колбэке не должен отменять доставку самого уведомления: об ошибке
+    # надо узнать в любом случае, кнопка — дополнение.
+    def build_keyboard(kind:, source:, context:, fingerprint:, exception: nil, message: nil)
+      return nil if config.buttons.nil?
+
+      rows = config.buttons.call(
+        kind: kind,
+        exception: exception,
+        message: message,
+        source: source,
+        context: context,
+        fingerprint: fingerprint
+      )
+      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)
       return nil if context.nil? || context.empty?
 
-      formatted = context.map { |k, v| "<b>#{escape(k.to_s)}:</b> #{escape(v.to_s)}" }
+      formatted = context.map { |k, v| "<b>#{escape(k.to_s)}:</b> #{escape(clamp(v, MAX_FIELD_LENGTH))}" }
       formatted.join("\n")
     end
 
-    def build_message_payload(message:, level:, source:, context: {})
+    def build_message_payload(message:, level:, source:, context: {}, thread_id: nil)
       text = [
         "<b>ℹ️ #{escape(resolve(config.app_name).to_s)}: #{escape(resolve(config.environment).to_s)}</b>",
         "<b>Source:</b> #{escape(source.to_s)}",
@@ -132,18 +249,57 @@ module TgErrorNotifier
         context_block(context)
       ].compact.join("\n")
 
-      {
+      payload = {
         chat_id: resolve(config.chat_id),
         text: truncate(text),
         parse_mode: "HTML",
         disable_web_page_preview: true
       }
+      payload[:message_thread_id] = thread_id if thread_id
+      keyboard = build_keyboard(
+        kind: :message,
+        message: message,
+        source: source,
+        context: context,
+        fingerprint: nil
+      )
+      payload[:reply_markup] = keyboard if keyboard
+      payload
+    end
+
+    def clamp(value, limit)
+      text = value.to_s
+      text.length > limit ? "#{text[0...limit]}…" : text
+    end
+
+    # Обрезка уже экранированного текста: не оставляем хвост от «&amp;»
+    def cut_escaped(text, limit)
+      return text if text.length <= limit
+
+      text[0...limit].sub(/&[#a-zA-Z0-9]*\z/, "")
     end
 
     def truncate(text)
       return text if text.length <= MAX_MESSAGE_LENGTH
 
-      text[0...MAX_MESSAGE_LENGTH] + "\n...truncated"
+      close_tags(cut_escaped(text, MAX_MESSAGE_LENGTH - 20)) + "\n...truncated"
+    end
+
+    # Обрезка могла оставить незакрытый тег или его половину — Telegram
+    # на таком отвечает 400 и сообщение не доходит вовсе
+    def close_tags(text)
+      text = text.sub(/<[^>]*\z/, "")
+
+      HTML_TAGS.each do |tag|
+        unclosed = text.scan("<#{tag}>").size - text.scan("</#{tag}>").size
+        unclosed.times { text += "</#{tag}>" }
+      end
+
+      text
+    end
+
+    def strip_html(text)
+      CGI.unescapeHTML(text.to_s.gsub(/<[^>]*>/, ""))
     end
 
     def resolve(value)

data/lib/tg_error_notifier/railtie.rb

@@ -22,6 +22,10 @@ module TgErrorNotifier
         config.logger = options.logger unless options.logger.nil?
         config.include_backtrace = options.include_backtrace unless options.include_backtrace.nil?
         config.active_job_enabled = options.active_job_enabled unless options.active_job_enabled.nil?
+        config.grouping_enabled = options.grouping_enabled unless options.grouping_enabled.nil?
+        config.grouping_window = options.grouping_window unless options.grouping_window.nil?
+        config.topics_enabled = options.topics_enabled unless options.topics_enabled.nil?
+        config.topic_icon_color = options.topic_icon_color unless options.topic_icon_color.nil?
       end
     end
 

data/lib/tg_error_notifier/topic_manager.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "set"
+
+module TgErrorNotifier
+  class TopicManager
+    ICON_COLOR_RED = 0xFB6F5F
+    ICON_COLOR_BLUE = 0x6FB9F0
+    MAX_TOPIC_NAME = 128
+    MAX_STORE_KEY = 200
+
+    def initialize(config)
+      @config = config
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @topics = {} # grouping_key => message_thread_id
+      @creating = Set.new
+    end
+
+    def thread_id_for(key, exception)
+      name = nil
+      store_key = "exception:#{key}"[0...MAX_STORE_KEY]
+
+      @mutex.synchronize do
+        # Wait if another thread is already creating this topic
+        while @creating.include?(key)
+          @condition.wait(@mutex, 10)
+        end
+
+        return @topics[key] if @topics.key?(key)
+
+        # Тема ошибки должна пережить рестарт и быть общей для всех
+        # процессов: иначе каждый puma/sidekiq-воркер заводит свой дубль
+        stored = store_read(store_key)
+        if stored
+          @topics[key] = stored
+          return stored
+        end
+
+        @creating.add(key)
+        name = topic_name(exception)
+      end
+
+      thread_id = create_topic(name)
+
+      @mutex.synchronize do
+        if thread_id
+          @topics[key] = thread_id
+          store_write(store_key, thread_id)
+        end
+        @creating.delete(key)
+        @condition.broadcast
+      end
+
+      thread_id
+    end
+
+    # Resolve thread_id for an explicitly named topic (capture_message topic: "...").
+    # Unlike exception topics, named topics survive restarts via the configured
+    # topic_store_read/topic_store_write callbacks.
+    def thread_id_for_name(name)
+      key = "topic:#{name}"
+
+      @mutex.synchronize do
+        while @creating.include?(key)
+          @condition.wait(@mutex, 10)
+        end
+
+        return @topics[key] if @topics.key?(key)
+
+        stored = store_read(name)
+        if stored
+          @topics[key] = stored
+          return stored
+        end
+
+        @creating.add(key)
+      end
+
+      thread_id = create_topic(truncate_name(name), icon_color: @config.topic_icon_color || ICON_COLOR_BLUE)
+
+      @mutex.synchronize do
+        if thread_id
+          @topics[key] = thread_id
+          store_write(name, thread_id)
+        end
+        @creating.delete(key)
+        @condition.broadcast
+      end
+
+      thread_id
+    end
+
+    private
+
+    def store_read(name)
+      reader = @config.topic_store_read
+      return nil unless reader
+
+      value = reader.call(name)
+      value.to_s.empty? ? nil : value.to_i
+    rescue StandardError => e
+      log("topic_store_read failed: #{e.class}: #{e.message}")
+      nil
+    end
+
+    def store_write(name, thread_id)
+      writer = @config.topic_store_write
+      return unless writer
+
+      writer.call(name, thread_id)
+    rescue StandardError => e
+      log("topic_store_write failed: #{e.class}: #{e.message}")
+    end
+
+    def truncate_name(name)
+      name = name.to_s.gsub(/\s+/, " ").strip
+      name.length > MAX_TOPIC_NAME ? "#{name[0...MAX_TOPIC_NAME - 1]}…" : name
+    end
+
+    def topic_name(exception)
+      truncate_name("#{exception.class.name}: #{exception.message}")
+    end
+
+    def create_topic(name, icon_color: nil)
+      token = resolve(@config.bot_token)
+      chat_id = resolve(@config.chat_id)
+      uri = URI("#{resolve(@config.api_base)}/bot#{token}/createForumTopic")
+
+      payload = {
+        chat_id: chat_id,
+        name: name,
+        icon_color: icon_color || @config.topic_icon_color || ICON_COLOR_RED
+      }
+
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      request.body = payload.to_json
+
+      http = build_http(uri)
+      response = http.request(request)
+
+      if response.is_a?(Net::HTTPSuccess)
+        data = JSON.parse(response.body)
+        data.dig("result", "message_thread_id")
+      else
+        log("createForumTopic failed: HTTP #{response.code} #{response.body}")
+        nil
+      end
+    rescue StandardError => e
+      log("createForumTopic error: #{e.class}: #{e.message}")
+      nil
+    end
+
+    def build_http(uri)
+      http = if @config.proxy?
+        Net::HTTP.new(uri.host, uri.port, resolve(@config.proxy_addr), resolve(@config.proxy_port).to_i, resolve(@config.proxy_user), resolve(@config.proxy_pass))
+      else
+        Net::HTTP.new(uri.host, uri.port)
+      end
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = @config.open_timeout
+      http.read_timeout = @config.read_timeout
+      http
+    end
+
+    def resolve(value)
+      value.respond_to?(:call) ? value.call : value
+    end
+
+    def log(message)
+      return unless @config.logger
+      @config.logger.error("[TgErrorNotifier::TopicManager] #{message}")
+    end
+  end
+end

data/lib/tg_error_notifier/version.rb

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

data/lib/tg_error_notifier.rb

@@ -3,6 +3,8 @@
 require "rails"
 require_relative "tg_error_notifier/version"
 require_relative "tg_error_notifier/configuration"
+require_relative "tg_error_notifier/grouper"
+require_relative "tg_error_notifier/topic_manager"
 require_relative "tg_error_notifier/notifier"
 require_relative "tg_error_notifier/middleware"
 require_relative "tg_error_notifier/subscriber"
@@ -28,8 +30,15 @@ module TgErrorNotifier
     end
 
     # API similar to Sentry.capture_message("text")
-    def capture_message(message, level: :info, source: "manual", context: {})
-      notifier.notify_message(message: message, level: level, source: source, context: context)
+    # topic: имя форум-топика — сообщение уйдёт в отдельную тему группы
+    # (топик создаётся один раз и переиспользуется через topic_store_read/write)
+    def capture_message(message, level: :info, source: "manual", context: {}, topic: nil)
+      notifier.notify_message(message: message, level: level, source: source, context: context, topic: topic)
+    end
+
+    def reset!
+      @configuration = nil
+      @notifier = nil
     end
 
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tg_error_notifier
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Sergei Ustinov
@@ -35,10 +35,12 @@ files:
 - README.md
 - lib/tg_error_notifier.rb
 - lib/tg_error_notifier/configuration.rb
+- lib/tg_error_notifier/grouper.rb
 - lib/tg_error_notifier/middleware.rb
 - lib/tg_error_notifier/notifier.rb
 - lib/tg_error_notifier/railtie.rb
 - lib/tg_error_notifier/subscriber.rb
+- lib/tg_error_notifier/topic_manager.rb
 - lib/tg_error_notifier/version.rb
 homepage: https://github.com/sergeyustinov/TgErrorNotifier
 licenses: