chat_notifier 0.2.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a442afb94e03ba8a40be94d62cb0043abe9a4a88430028bb79a5655ebe2d1f7e
-  data.tar.gz: 2070d04462fc7d9fec4daf08b25e900f03d5d7ce735aa5ac51eace3acc6429c6
+  metadata.gz: 945c1f49cd9931c5e86f1f3597156a1c109255bf90a411075770745c4ed5ce63
+  data.tar.gz: 8becdc536e0b80a656b99cbf9b5a525763c46e02164816331f424798f6be3dc5
 SHA512:
-  metadata.gz: e892f14d366c45b01b3665523ee7b47eba8ad9b15021351b3f626763a08bacce3b72bdd5a6425338e5e1a5b3d94c3ae2294c3c92809060607b9bfa9b8aeaa273
-  data.tar.gz: 4a7cdd3397d62a9c7a9e25ea9b1bbf669a9e1c92eac97b95900764df0bc62b878cbd7e7942612852199a8ecd6efff13b0c6ed3604a7160b3d40b8da709e86c3d
+  metadata.gz: 0c1f2d3dde65aef1acfdf4a313d0c312a031acac824bff21f64cfbfa86ff951aaea14da04209e49f7063a05bace6657165378afd84858242d8bdee0e55fd9807
+  data.tar.gz: 2547ee1bb2ea7a6532ef1b404812b4f9fea61cb38d0e50e1548399d8dee072e1d1da17b8be484a8a22b074f1f8c476099cdc092425339e386324faf268821b5b

data/CHANGELOG.md

@@ -5,24 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.5] - 2026-02-02
+## [0.4.0] - 2026-07-24
 
 ### Added
 
-- Dependabot configuration with weekly updates
+- Rate-limited posts retry once, honoring Slack's Retry-After (b2d5a6d)
+- HTTP requests use explicit open/read timeouts so notifications cannot hang the suite (b2d5a6d)
+- One Slack thread per breakage episode on a branch/PR, shared across parallel CI jobs, with the parent message maintained as a live status digest (38b8fff)
+- Passing runs resolve open failure episodes, updating the thread parent to resolved (38b8fff)
 
-### Changed
+### Fixed
 
-- Moved ENV variable setting `NOTIFY_APP_NAME` into the test helper
-- Refactored method signatures for easier testing
+- Slack API responses with ok:false are now logged instead of silently dropped (b2d5a6d)
+- Error logging names the chatter class instead of leaking the webhook URL (b2d5a6d)
+- Slack handler no longer activates without a webhook URL or bot token (b2d5a6d)
+- Malformed NOTIFY_SLACK_THREAD_GROUP_SIZE falls back to the default (b2d5a6d)
+- Replies are skipped when the parent response has no ts, instead of posting unthreaded (b2d5a6d)
+- Notifications no longer fail silently: branch and sha now resolve from CI env or git instead of raising on the app name (8cb8603)
 
-### Removed
+## [0.3.0] - 2026-07-24
 
-- OpenStruct dependency
-
-## [0.2.4] - 2025-01-16
-
-### Changed
+### Added
 
-- Add support for Ruby 3.4
-- Check for Rails application before using Rails.application
+- Threaded Slack failure notifications via a Slack bot token (NOTIFY_SLACK_BOT_TOKEN), grouping failing files into batched thread replies (e453cd0)

data/README.md

@@ -51,6 +51,55 @@ If you are _not_ using Rails, you will need to add this ENV variable:
       NOTIFY_APP_NAME
 ```
 
+### Threaded failure notifications (optional)
+
+Incoming webhooks post a single message. If you instead provide a Slack **bot
+token**, ChatNotifier uses the Slack Web API and threads failures: it posts the
+branch/run summary as a parent message, then posts the failing files — grouped
+into reasonably sized batches — as threaded replies.
+
+```
+      NOTIFY_SLACK_BOT_TOKEN        # xoxb-… bot token; enables threading
+      NOTIFY_SLACK_NOTIFY_CHANNEL   # channel ID (C…) — required for episode threading; a #name only posts
+      NOTIFY_SLACK_THREAD_GROUP_SIZE # optional, files per reply (default 10)
+```
+
+When both `NOTIFY_SLACK_BOT_TOKEN` and `NOTIFY_SLACK_WEBHOOK_URL` are set, the
+bot token is preferred. The bot needs the `chat:write` scope.
+
+### Episode threading (bot token only)
+
+With a bot token, ChatNotifier keeps **one thread per breakage episode** on a
+branch/PR — shared across parallel CI jobs (matrix builds). Parent messages
+carry message metadata; each job finds the episode thread by scanning channel
+history, so no shared storage is needed. The parent is a live status digest
+updated as each job reports (e.g. `test ruby-3.2 ❌ 12 · test ruby-3.3 ✅`) and
+flips to ✅ resolved when the latest run is all green. Passing runs post
+nothing unless they resolve a known open episode.
+
+```
+      NOTIFY_THREAD_STORE           # set to "none" to opt out of episode threading
+      NOTIFY_JOB_NAME               # optional job identity (default: GITHUB_JOB + ruby version)
+```
+
+`GITHUB_RUN_ATTEMPT` is picked up automatically, so "Re-run failed jobs"
+supersedes earlier attempts in the digest.
+
+In addition to `chat:write`, the bot needs `channels:history` (and
+`groups:history` for private channels) to find episode threads, and it must be
+a **member of the channel** (`/invite @YourBot`). Use the channel **ID** in
+`NOTIFY_SLACK_NOTIFY_CHANNEL`: posting accepts a `#name`, but the history
+lookup does not, so a name degrades to per-job threads. Missing scopes or
+membership degrade gracefully: the lookup logs an error and each job falls
+back to its own thread.
+
+Caveats: verbose mode (`NOTIFIER_VERBOSE`) posts plain messages and bypasses
+episode resolution, and a thread store passed programmatically
+(`ChatNotifier.call(thread_store: ...)`) takes precedence over
+`NOTIFY_THREAD_STORE=none`. A single CI job running both RSpec and Minitest
+posts two status reports under the same job identity and only the earliest per
+run counts in the digest — set `NOTIFY_JOB_NAME` per framework to disambiguate.
+
 ### Debug your Slack setup
 
 Create rake task to test the connection to your Slack channel

data/lib/chat_notifier/app.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ChatNotifier
+  # The application under test: its name plus the source control context
+  # (branch and sha), resolved from CI-standard settings with git fallbacks.
+  class App
+    def initialize(name:, settings:, runner: method(:capture))
+      @name = name
+      @settings = settings
+      @runner = runner
+    end
+
+    attr_reader :name, :settings, :runner
+
+    def to_s = name
+
+    def branch
+      return @branch if defined?(@branch)
+
+      @branch = from_settings("NOTIFY_BRANCH", "GITHUB_HEAD_REF", "GITHUB_REF_NAME") ||
+        git("branch --show-current")
+    end
+
+    def sha
+      return @sha if defined?(@sha)
+
+      @sha = from_settings("NOTIFY_SHA", "GITHUB_SHA") ||
+        git("rev-parse --short HEAD")
+    end
+
+    private
+
+    def from_settings(*keys)
+      keys.each do |key|
+        value = settings[key]
+        return value unless value.nil? || value.empty?
+      end
+      nil
+    end
+
+    def git(command)
+      value = runner.call("git #{command}").to_s.chomp
+      value.empty? ? nil : value
+    rescue
+      nil
+    end
+
+    def capture(command)
+      `#{command} 2>/dev/null`
+    end
+  end
+end

data/lib/chat_notifier/chatter/slack.rb

@@ -1,13 +1,23 @@
 # frozen_string_literal: true
 
+require_relative "../failure_groups"
+
 module ChatNotifier
   class Chatter
     class Slack < self
       Chatter.register self
 
+      API_URL = "https://slack.com/api/chat.postMessage"
+      REPLIES_URL = "https://slack.com/api/conversations.replies"
+      UPDATE_URL = "https://slack.com/api/chat.update"
+      DEFAULT_THREAD_GROUP_SIZE = 10
+      STATUS_EVENT_TYPE = "chat_notifier_status"
+
       class << self
         def handles?(settings)
-          !settings.keys.grep(/NOTIFY_SLACK/).empty?
+          %w[NOTIFY_SLACK_WEBHOOK_URL NOTIFY_SLACK_BOT_TOKEN].any? do |key|
+            settings.fetch(key, nil)
+          end
         end
       end
 
@@ -15,14 +25,194 @@ module ChatNotifier
         settings.fetch("NOTIFY_SLACK_WEBHOOK_URL", nil)
       end
 
+      def bot_token
+        settings.fetch("NOTIFY_SLACK_BOT_TOKEN", nil)
+      end
+
       def channel
         settings.fetch("NOTIFY_SLACK_NOTIFY_CHANNEL", nil)
       end
 
+      def thread_group_size
+        Integer(settings.fetch("NOTIFY_SLACK_THREAD_GROUP_SIZE", DEFAULT_THREAD_GROUP_SIZE))
+      rescue ArgumentError, TypeError
+        DEFAULT_THREAD_GROUP_SIZE
+      end
+
+      # Injectable pause used when Slack rate-limits a post.
+      attr_writer :sleeper
+
+      def sleeper
+        @sleeper ||= Kernel.method(:sleep)
+      end
+
+      # When a bot token is configured we use the Slack Web API, which can
+      # thread failures. The token path is preferred over an incoming webhook.
+      def post(messenger, process: method(:http_post))
+        return super unless bot_token
+
+        post_via_api(messenger, process:)
+      end
+
+      def conditional_post(messenger, process: method(:http_post))
+        return super unless bot_token
+        return post(messenger, process:) if messenger.failure? || verbose?
+
+        resolve_episode(messenger, process:)
+      end
+
       def payload(data)
         super(Configuration.for(data, self).to_h)
       end
 
+      # Slack read APIs (conversations.history, conversations.replies) take
+      # form-encoded params rather than JSON bodies.
+      def api_form_post(url, params, process: method(:http_post))
+        response = process.call(URI(url), URI.encode_www_form(params), form_headers)
+        parsed_response(response)
+      end
+
+      # With a bot token the channel itself can store thread metadata.
+      def default_thread_store
+        return super unless bot_token
+
+        ThreadStore::SlackMetadata.new(chatter: self)
+      end
+
+      private
+
+      # Success posts nothing unless an open episode exists for this key:
+      # then a passed status reply closes the loop and the digest flips the
+      # parent to resolved.
+      def resolve_episode(messenger, process:)
+        ref = thread_store.find(messenger.thread_key, process:)
+        return unless ref&.open?
+
+        post_message(text: status_text(messenger), thread_ts: ref.ts, process:,
+          metadata: {event_type: STATUS_EVENT_TYPE, event_payload: messenger.status_report})
+        update_parent(messenger, ref.ts, process:)
+      end
+
+      def post_via_api(messenger, process:)
+        return post_message(text: messenger.message, process:) unless messenger.failure?
+
+        key = messenger.thread_key
+        ref = thread_store.find(key, process:)
+        thread_ts = ref&.open? ? ref.ts : nil
+
+        unless thread_ts
+          parent = post_message(text: messenger.lede, process:, metadata: parent_metadata(key))
+          return parent unless ok?(parent)
+          thread_ts = response_ts(parent)
+          return parent unless thread_ts
+        end
+
+        FailureGroups.new(messenger.failures, group_size: thread_group_size).reply_texts.each do |text|
+          post_message(text:, thread_ts:, process:)
+        end
+
+        post_message(text: status_text(messenger), thread_ts:, process:,
+          metadata: {event_type: STATUS_EVENT_TYPE, event_payload: messenger.status_report})
+
+        update_parent(messenger, thread_ts, process:)
+      end
+
+      # The parent message is a materialized view of the thread: refetch the
+      # status replies and recompute its text and status via chat.update.
+      # Fetch and update are not atomic (Slack has no compare-and-set), so a
+      # concurrent job can win the last write; the next event repairs it.
+      def update_parent(messenger, thread_ts, process:)
+        replies = api_form_post(REPLIES_URL,
+          {channel: channel, ts: thread_ts, include_all_metadata: true, limit: 1000}, process:)
+        return unless replies["ok"]
+
+        if replies["has_more"]
+          ChatNotifier.logger.warn("ChatNotifier: thread replies truncated; parent digest may be stale")
+        end
+
+        reports = (replies["messages"] || []).filter_map do |message|
+          message.dig("metadata", "event_payload") if message.dig("metadata", "event_type") == STATUS_EVENT_TYPE
+        end
+        return if reports.empty?
+
+        status = messenger.resolved?(reports) ? "resolved" : "failing"
+        body = {channel: channel, ts: thread_ts, text: messenger.digest(reports),
+                metadata: {event_type: ThreadStore::SlackMetadata::EVENT_TYPE,
+                           event_payload: {key: messenger.thread_key, status: status}}}
+        log_api_error(process.call(URI(UPDATE_URL), body.to_json, api_headers))
+      end
+
+      def status_text(messenger)
+        report = messenger.status_report
+        "#{report[:job]}: #{report[:status]}"
+      end
+
+      def parent_metadata(key)
+        {event_type: ThreadStore::SlackMetadata::EVENT_TYPE,
+         event_payload: {key: key, status: "failing"}}
+      end
+
+      def post_message(text:, process:, thread_ts: nil, metadata: nil)
+        body = {channel: channel, text: text}
+        body[:thread_ts] = thread_ts if thread_ts
+        body[:metadata] = metadata if metadata
+        deliver = -> { process.call(URI(API_URL), body.to_json, api_headers) }
+
+        response = deliver.call
+        if rate_limited?(response)
+          sleeper.call(retry_after(response))
+          response = deliver.call
+        end
+        log_api_error(response)
+        response
+      end
+
+      def rate_limited?(response)
+        response.respond_to?(:code) && response.code.to_s == "429"
+      end
+
+      def retry_after(response)
+        Integer(response["Retry-After"])
+      rescue ArgumentError, TypeError
+        1
+      end
+
+      def log_api_error(response)
+        parsed = parsed_response(response)
+        return if parsed["ok"] == true
+
+        error = parsed.fetch("error", "unrecognized response")
+        ChatNotifier.logger.error("ChatNotifier: Slack API error: #{error}")
+      end
+
+      def api_headers
+        {
+          "Content-Type" => "application/json; charset=utf-8",
+          "Authorization" => "Bearer #{bot_token}"
+        }
+      end
+
+      def form_headers
+        {
+          "Content-Type" => "application/x-www-form-urlencoded",
+          "Authorization" => "Bearer #{bot_token}"
+        }
+      end
+
+      def ok?(response)
+        parsed_response(response)["ok"] == true
+      end
+
+      def response_ts(response)
+        parsed_response(response)["ts"]
+      end
+
+      def parsed_response(response)
+        JSON.parse(response.body.to_s)
+      rescue JSON::ParserError
+        {}
+      end
+
       class Configuration
         def self.for(messenger, communicator)
           if messenger.failure?

data/lib/chat_notifier/chatter.rb

@@ -4,9 +4,14 @@ require "net/http"
 require "uri"
 require "json"
 
+require_relative "thread_store"
+
 module ChatNotifier
   # All behavior for interacting with a notification platform
   class Chatter
+    OPEN_TIMEOUT = 5
+    READ_TIMEOUT = 10
+
     def initialize(settings:, repository:, environment:)
       @settings = settings
       @repository = repository
@@ -45,22 +50,51 @@ module ChatNotifier
     def body
     end
 
-    def post(messenger, process: Net::HTTP.method(:post))
+    def post(messenger, process: method(:http_post))
       uri = URI(webhook_url)
 
       process.call(uri, payload(messenger))
     end
 
-    def conditional_post(messenger, process: Net::HTTP.method(:post))
+    def conditional_post(messenger, process: method(:http_post))
       return if messenger.success? && !verbose?
 
       post(messenger, process:)
     end
 
+    def http_client(uri)
+      Net::HTTP.new(uri.host, uri.port).tap do |http|
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = OPEN_TIMEOUT
+        http.read_timeout = READ_TIMEOUT
+      end
+    end
+
+    def http_post(uri, body, headers = nil)
+      http_client(uri).start do |http|
+        http.request_post(uri.request_uri, body, headers)
+      end
+    end
+
     def verbose?
       !!settings.fetch("NOTIFIER_VERBOSE", false)
     end
 
+    # Injectable store mapping thread keys to existing chat threads.
+    attr_writer :thread_store
+
+    def thread_store
+      @thread_store ||= if settings.fetch("NOTIFY_THREAD_STORE", nil) == "none"
+        ThreadStore::Null.new
+      else
+        default_thread_store
+      end
+    end
+
+    def default_thread_store
+      ThreadStore::Null.new
+    end
+
     def payload(data)
       data.to_json
     end

data/lib/chat_notifier/failure_groups.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ChatNotifier
+  # Groups test failures by file and packs them into reasonably sized
+  # batches suitable for posting as individual Slack thread replies.
+  class FailureGroups
+    def initialize(failures, group_size: 10, char_limit: 3000)
+      @failures = failures
+      @group_size = group_size
+      @char_limit = char_limit
+    end
+
+    attr_reader :failures, :group_size, :char_limit
+
+    # One rendered string per thread reply: file blocks packed into batches
+    # bounded by group_size (file count) and char_limit (rendered length).
+    def reply_texts
+      batches.map { |blocks| blocks.join("\n") }
+    end
+
+    private
+
+    def batches
+      file_blocks.each_with_object([]) do |block, packed|
+        current = packed.last
+        if current.nil? ||
+            current.size >= group_size ||
+            (current.join("\n").length + 1 + block.length) > char_limit
+          packed << [block]
+        else
+          current << block
+        end
+      end
+    end
+
+    # Render each file (with its failing lines) into a text block.
+    def file_blocks
+      by_file.map do |file, lines|
+        bullets = lines.map { |line| "  • #{File.basename(file)}:#{line}" }
+        ([file] + bullets).join("\n")
+      end
+    end
+
+    # { "path/to/file.rb" => ["42", "88"], ... } preserving first-seen order.
+    def by_file
+      failures.each_with_object({}) do |failure, groups|
+        file, line = normalize(failure.location)
+        (groups[file] ||= []) << line
+      end
+    end
+
+    # RSpec locations are "path:line" strings; Minitest locations are
+    # [file, line] arrays. Normalize both to [file, line].
+    def normalize(location)
+      if location.is_a?(Array)
+        [location[0], location[1]]
+      else
+        file, _, line = location.to_s.rpartition(":")
+        [file, line]
+      end
+    end
+  end
+end

data/lib/chat_notifier/messenger.rb

@@ -56,12 +56,45 @@ module ChatNotifier
       "#{app} #{ruby_version} #{sha}"
     end
 
+    def thread_key
+      "#{app}##{environment.pull_request_ref || branch}"
+    end
+
     def message_prefix = ":thumbsup:"
 
+    def status_report
+      # The payload field stays named run_id (persisted in existing threads)
+      # but carries run_key so re-run attempts group as newer runs.
+      {job: environment.job_identifier, status: "passed", failures: 0, run_id: environment.run_key}
+    end
+
     def success? = true
 
     def failure? = !success?
 
+    # Render a parent-message summary from the thread's status reports,
+    # keeping only the latest run's report per job. A pure function of the
+    # reports plus state shared across matrix jobs (app, sha, branch,
+    # test_run_url) — never the writer's own ruby version or success state —
+    # so any writer, in any order, converges on identical text.
+    def digest(reports)
+      latest = latest_run(reports)
+      parts = latest.sort_by { |report| report["job"].to_s }.map do |report|
+        if report["status"] == "passed"
+          "#{report["job"]} ✅"
+        else
+          "#{report["job"]} ❌ #{report["failures"]}"
+        end
+      end
+      prefix = resolved?(reports) ? "✅" : ":boom:"
+      "#{prefix} #{app} #{sha} in #{branch} · #{parts.join(" · ")}\n#{environment.test_run_url}"
+    end
+
+    def resolved?(reports)
+      latest = latest_run(reports)
+      !latest.empty? && latest.all? { |report| report["status"] == "passed" }
+    end
+
     def to_h
       {
         text: message
@@ -79,6 +112,10 @@ module ChatNotifier
 
       def failure? = !success?
 
+      def status_report
+        super.merge(status: "failed", failures: failures.size)
+      end
+
       def lede
         <<~LEDE.chomp
           #{message_prefix} #{identifier} has failed #{count} in #{branch}
@@ -99,5 +136,17 @@ module ChatNotifier
         failures.flat_map(&:location).join("\n")
       end
     end
+
+    private
+
+    def latest_run(reports)
+      grouped = reports.group_by { |report| report["run_id"].to_s }
+      latest_id = grouped.keys.max_by { |id| [id.length, id] }
+      # [length, value] orders numeric strings correctly ("9" < "10") and
+      # sorts nil run_ids ("") as the oldest run.
+      # conversations.replies returns replies oldest-first, so uniq keeps the
+      # earliest status per job per run; jobs post once per run, so it's fine.
+      grouped.fetch(latest_id, []).uniq { |report| report["job"] }
+    end
   end
 end

data/lib/chat_notifier/test_environment/github.rb

@@ -8,7 +8,25 @@ module ChatNotifier
       end
 
       def run_id
-        settings.fetch("NOTIFY_TEST_RUN_ID")
+        settings.fetch("NOTIFY_TEST_RUN_ID") do
+          settings.fetch("GITHUB_RUN_ID", nil)
+        end
+      end
+
+      # "Re-run failed jobs" reuses GITHUB_RUN_ID (only GITHUB_RUN_ATTEMPT
+      # changes), so the attempt suffix lets a re-run pass supersede the
+      # original failure in the digest instead of being dropped as a
+      # duplicate of the same run.
+      def run_key
+        attempt = settings.fetch("GITHUB_RUN_ATTEMPT", nil)
+        return run_id unless run_id && attempt
+
+        "#{run_id}.#{attempt}"
+      end
+
+      def pull_request_ref
+        ref = settings.fetch("GITHUB_HEAD_REF", nil)
+        ref unless ref.nil? || ref.empty?
       end
     end
   end

data/lib/chat_notifier/test_environment.rb

@@ -27,6 +27,23 @@ module ChatNotifier
 
     def test_run_url
     end
+
+    def job_identifier
+      settings.fetch("NOTIFY_JOB_NAME") do
+        job = settings.fetch("GITHUB_JOB", "test")
+        "#{job} ruby-#{RUBY_VERSION}"
+      end
+    end
+
+    def run_id
+    end
+
+    # Key used to group status reports by run in the parent digest. Distinct
+    # from run_id (which URLs need bare) so re-runs can sort as newer runs.
+    def run_key = run_id
+
+    def pull_request_ref
+    end
   end
 end
 

data/lib/chat_notifier/thread_store/slack_metadata.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ChatNotifier
+  class ThreadStore
+    # Uses the Slack channel itself as the store: parents are posted with
+    # message metadata carrying the thread key; find scans recent history.
+    class SlackMetadata < self
+      EVENT_TYPE = "chat_notifier_thread"
+      HISTORY_URL = "https://slack.com/api/conversations.history"
+      HISTORY_LIMIT = 200
+
+      def initialize(chatter:)
+        @chatter = chatter
+      end
+
+      attr_reader :chatter
+
+      def find(key, process: nil)
+        response = fetch_history(process)
+        unless response["ok"]
+          ChatNotifier.logger.error(
+            "ChatNotifier: thread lookup failed: #{response.fetch("error", "unrecognized response")}"
+          )
+          return nil
+        end
+        message = matching_message(response, key)
+        return nil unless message
+
+        ThreadRef.new(ts: message["ts"], status: message.dig("metadata", "event_payload", "status"))
+      rescue => error
+        # A failed lookup must never abort posting the notification itself.
+        ChatNotifier.logger.error("ChatNotifier: thread lookup failed: #{error.message}")
+        nil
+      end
+
+      # Posting the parent with metadata is the record; nothing separate to do.
+      def record(key, ref) = nil
+
+      private
+
+      # A nil process defers to the chatter's own default transport.
+      def fetch_history(process)
+        params = {
+          channel: chatter.channel,
+          limit: HISTORY_LIMIT,
+          include_all_metadata: true
+        }
+        return chatter.api_form_post(HISTORY_URL, params) unless process
+
+        chatter.api_form_post(HISTORY_URL, params, process:)
+      end
+
+      def matching_message(response, key)
+        (response["messages"] || []).find do |message|
+          message.dig("metadata", "event_type") == EVENT_TYPE &&
+            message.dig("metadata", "event_payload", "key") == key
+        end
+      end
+    end
+  end
+end

data/lib/chat_notifier/thread_store.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ChatNotifier
+  # Strategy for persisting the mapping from a branch/PR key to a chat thread.
+  # Implementations provide find(key, process: nil) => ThreadRef | nil and
+  # record(key, ref). The optional process is an injectable transport callable
+  # passed through by callers; nil means use the implementation's default.
+  class ThreadStore
+    ThreadRef = Data.define(:ts, :status) do
+      def open? = status != "resolved"
+    end
+
+    class Null < self
+      def find(key, process: nil) = nil
+
+      def record(key, ref) = nil
+    end
+  end
+end
+
+require_relative "thread_store/slack_metadata"

data/lib/chat_notifier/version.rb

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

data/lib/chat_notifier.rb

@@ -2,7 +2,9 @@
 
 require_relative "chat_notifier/version"
 
+require_relative "chat_notifier/app"
 require_relative "chat_notifier/messenger"
+require_relative "chat_notifier/thread_store"
 require_relative "chat_notifier/repository"
 require_relative "chat_notifier/test_environment"
 require_relative "chat_notifier/chatter"
@@ -43,7 +45,7 @@ module ChatNotifier
       )
       messenger = (kwargs[:messenger] || STANDARDS[:messenger]).for(
         summary,
-        app:,
+        app: App.new(name: app(env:), settings: env),
         repository:,
         environment:
       )
@@ -60,9 +62,13 @@ module ChatNotifier
         environment:
       )
 
+      if (store = kwargs[:thread_store])
+        chatter.each { |box| box.thread_store = store }
+      end
+
       messenger = (kwargs[:messenger] || STANDARDS[:messenger]).for(
         summary,
-        app:,
+        app: App.new(name: app, settings: ENV),
         repository:,
         environment:
       )
@@ -70,7 +76,7 @@ module ChatNotifier
       chatter.each do |box|
         box.conditional_post(messenger)
       rescue => exception
-        logger.error("ChatNotifier: #{box.webhook_url} #{exception.class}: #{exception.message}")
+        logger.error("ChatNotifier: #{box.class} #{exception.class}: #{exception.message}")
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_notifier
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.4.0
 platform: ruby
 authors:
 - Jim Gay
@@ -9,7 +9,21 @@ authors:
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Send test results to chat
 email:
 - jim@saturnflyer.com
@@ -22,9 +36,11 @@ files:
 - LICENSE.txt
 - README.md
 - lib/chat_notifier.rb
+- lib/chat_notifier/app.rb
 - lib/chat_notifier/chatter.rb
 - lib/chat_notifier/chatter/debug.rb
 - lib/chat_notifier/chatter/slack.rb
+- lib/chat_notifier/failure_groups.rb
 - lib/chat_notifier/messenger.rb
 - lib/chat_notifier/repository.rb
 - lib/chat_notifier/repository/debug.rb
@@ -33,6 +49,8 @@ files:
 - lib/chat_notifier/test_environment.rb
 - lib/chat_notifier/test_environment/debug.rb
 - lib/chat_notifier/test_environment/github.rb
+- lib/chat_notifier/thread_store.rb
+- lib/chat_notifier/thread_store/slack_metadata.rb
 - lib/chat_notifier/version.rb
 - lib/minitest/chat_notifier_plugin.rb
 licenses: []
@@ -46,7 +64,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="