raider_reporter 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61be0da46b6e8038ccb7da397ce371e20e398792aaa42aff9e93e2e765efd73b
-  data.tar.gz: 9d2859ced0b58e73ccd0f8d90fece82b3d8f379bca46ef958edb8089e81ae30e
+  metadata.gz: 43cb5da1df209da0c5607c26891e58a868982311569e8f844d80b87a46943f14
+  data.tar.gz: 82099d1f6c53736ef7f9d075207887581e6280af14a4d0335008ef54712ee48b
 SHA512:
-  metadata.gz: a805ca67f914f9413cb95913b2015c7a56020564bf709a45aadd96c25f183a374927fd572b6dab80cf2969adca7b2d6305edd04b617d0414f1af2caba108ddc4
-  data.tar.gz: 1f9ba4407c3677d5166ec09aced32f3d2c43ac4a599468eda510f3e7327ce417d6eea25af8de47ea308bacde60e45b9c8ba36414434bd0bd0d938bb2ecdd1bfc
+  metadata.gz: 276522de77789af81f1534ca8980cd3e168915963c2dd52b1863d2aa7ca4f5bfb54d3fecd018498931dcc45d58905adc331388ba26d152797e0800e421ab9688
+  data.tar.gz: b980514dc7c2a51d08cb89de5caf549a648406cbce998159d706d4397735c1eb1af37221eaf354d4e383104facf1025917b4ce12d21fc1937b68c38964960b61

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.5.1 — 2026-10-13
+
+- Fix: a failed upload now reports one short line. An HTML error page (for example a server 500) is summarised as `the server returned an HTML error page` instead of being printed, other bodies are collapsed to one line of at most 200 characters, and the token is redacted from upload errors, including exception messages
+- Docs: the Azure Pipelines snippet publishes `raider-results-$(System.JobPositionInPhase)-$(System.JobAttempt)`, so re-running failed jobs or `strategy: parallel` no longer collides on the artifact name
+
+## 0.5.0 — 2026-10-12
+
+- Add Azure Pipelines support: detect the build (`provider: azure_pipelines`, build URL, attempt, job, branch, commit), report Azure Repos pull requests in `run.git.pr`, and derive a stable id-based build key. `strategy: parallel` jobs are detected as shards of one build
+- `raider-reporter comment` now works on Azure Pipelines: it creates or updates one tagged comment thread on the pull request (closed when the build passed) and sets a `raider/tests` PR status. Uses `System.AccessToken` with the PR statuses API version 7.1; the build service needs "Contribute to pull requests" on the repository. GitHub-hosted repositories built by Azure Pipelines are skipped with a notice
+- Schema v1, additive: optional `run.git.pr.url` (set by GitHub Actions and Azure Pipelines)
+- Unexpanded Azure macros such as `$(RAIDER_TOKEN)` or `$(System.AccessToken)` are treated as missing instead of being sent as a token
+- Fix: redact the token before truncating error bodies in the GitHub and Azure clients, so a token straddling the 200-character cut can no longer leak partially
+- Notices: the missing-permission notice uses `<project>` when the project name is unknown, and the success notice prints `PR #<n>` when the PR URL is unknown
+- `raider-reporter comment` now runs only on GitHub Actions (`GITHUB_ACTIONS=true`) or Azure Pipelines; elsewhere it prints `skipped: unsupported CI` and exits 0
+- No breaking changes
+
 ## 0.4.0 — 2026-10-11
 
 - Add a Cucumber reporter (Cucumber >= 9, < 12; not a gem dependency). `require "raider_reporter/cucumber"` from `features/support/` registers it in plugin mode (recommended, works with any `--format` and no `--out`); `--format RaiderReporter::Cucumber::Formatter --out <file>` also works. Using both registers one listener

data/README.md

@@ -195,6 +195,50 @@ On pull requests, `raider-reporter comment` posts one comment with the build's r
 - The command never fails your CI: it always exits 0 and prints notices to stderr, prefixed `[raider_reporter]`. It needs `GITHUB_TOKEN`, `GITHUB_REPOSITORY`, `GITHUB_EVENT_PATH`, `RAIDER_TOKEN` and `RAIDER_ENDPOINT`; if one is missing, or the event is not a pull request, it does nothing.
 - It requires a Raider server that supports the summary endpoint and the `git.pr` field. Upgrade the server before using it.
 
+## Azure Pipelines
+
+The gem detects Azure Pipelines when `TF_BUILD` is `true`. It reports the build (`provider: azure_pipelines`, build URL, attempt, job), the branch and commit, the pull request and a build key, so shards of one build group together. On a pull request from Azure Repos, `raider-reporter comment` posts one comment thread with the results and sets a `raider/tests` status on the PR.
+
+```yaml
+jobs:
+  - job: tests
+    steps:
+      - task: UseRubyVersion@0
+        inputs: { versionSpec: '3.4' }
+      - script: bundle install
+        displayName: Install gems
+      - script: bundle exec rspec spec/ --format documentation
+        displayName: Run tests
+        env:
+          RAIDER_TOKEN: $(RAIDER_TOKEN)
+          RAIDER_ENDPOINT: $(RAIDER_ENDPOINT)
+      - task: PublishPipelineArtifact@1
+        condition: always()
+        inputs: { targetPath: raider-results, artifact: raider-results-$(System.JobPositionInPhase)-$(System.JobAttempt) }
+  - job: raider_comment
+    dependsOn: tests
+    condition: and(always(), eq(variables['Build.Reason'], 'PullRequest'))
+    steps:
+      - task: UseRubyVersion@0
+        inputs: { versionSpec: '3.4' }
+      - script: bundle install
+      - script: bundle exec raider-reporter comment
+        displayName: Comment Raider results on the pull request
+        env:
+          RAIDER_TOKEN: $(RAIDER_TOKEN)
+          RAIDER_ENDPOINT: $(RAIDER_ENDPOINT)
+          SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+```
+
+- **One-time grant:** give "Contribute to pull requests" to `<Project> Build Service (<org>)` on the repository (Project settings > Repositories > Security). Without it the command prints a notice naming the exact identity and exits 0.
+- **Map secrets explicitly:** Azure does not expose secret variables to scripts automatically. Map `RAIDER_TOKEN` and `System.AccessToken` with `env:` as shown. If a mapped variable is undefined, Azure passes the literal `$(...)`; the gem treats it as missing: results are still written locally but not uploaded, and `raider-reporter comment` prints a skip notice.
+- **Pull request builds:** for Azure Repos, YAML `pr:` triggers are ignored. PR builds (and therefore the comment job) run only when the pipeline is added as a **Build validation** branch policy on the target branch.
+- **Same stage:** keep the comment job in the same stage as the test jobs; the build key includes `System.StageAttempt`.
+- **Artifact names:** pipeline artifacts cannot be overwritten within a run, so the name includes the job position and attempt. A fixed name would fail when you re-run failed jobs or use `strategy: parallel`.
+- **Azure Repos only:** the PR comment works for repositories hosted in Azure Repos. A GitHub-hosted repository built by Azure Pipelines still uploads results, but `comment` prints `skipped: not an Azure Repos pull request`.
+- **Parallel jobs:** `strategy: parallel: N` shards are detected automatically and grouped into one build, like GitHub matrix jobs.
+- The command never fails your pipeline: it always exits 0 and prints notices to stderr, prefixed `[raider_reporter]`. It needs `SYSTEM_ACCESSTOKEN`, `RAIDER_TOKEN` and `RAIDER_ENDPOINT`, and requires a Raider server that supports the summary endpoint.
+
 ## Parallel runs
 
 When a suite is split across several processes or CI jobs, each one uploads its own run. Raider groups runs of the same CI build, so the shards show up together as one build. Each run records its shard (`index`, `total` and a `label`) and, on GitHub Actions, a build key made from the repository, run id and run attempt. A re-run attempt of a workflow is a separate build.

data/lib/raider_reporter/azure_env.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RaiderReporter
+  # Reads Azure Pipelines variables. An undefined macro is left literal by Azure
+  # ("$(System.AccessToken)"), so such values count as missing.
+  module AzureEnv
+    MACRO = /\A\$\(.+\)\z/
+
+    module_function
+
+    def value(env, name)
+      raw = env[name].to_s.strip
+      raw.empty? || raw.match?(MACRO) ? nil : raw
+    end
+
+    def azure?(env)
+      env["GITHUB_ACTIONS"] != "true" && value(env, "TF_BUILD")&.casecmp?("true") == true
+    end
+
+    def collection_base(env)
+      uri = value(env, "SYSTEM_COLLECTIONURI")
+      uri && "#{uri.sub(%r{/+\z}, '')}/"
+    end
+
+    def azure_repos_pr?(env)
+      value(env, "BUILD_REASON") == "PullRequest" && value(env, "BUILD_REPOSITORY_PROVIDER") == "TfsGit"
+    end
+
+    def strip_heads(ref)
+      return nil if ref.nil?
+      return ref.delete_prefix("refs/heads/") if ref.start_with?("refs/heads/")
+
+      ref.start_with?("refs/") ? nil : ref
+    end
+  end
+end

data/lib/raider_reporter/ci_detector.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "erb"
 require "open3"
+require "raider_reporter/azure_env"
 require "raider_reporter/github_event"
 
 module RaiderReporter
@@ -14,6 +16,7 @@ module RaiderReporter
     end
 
     def ci
+      return azure_ci if AzureEnv.azure?(@env)
       return nil unless @env["GITHUB_ACTIONS"] == "true"
 
       run_id = @env["GITHUB_RUN_ID"]
@@ -38,6 +41,40 @@ module RaiderReporter
 
     private
 
+    def azure_ci
+      v = ->(name) { AzureEnv.value(@env, name) }
+      base = AzureEnv.collection_base(@env)
+      project = v.("SYSTEM_TEAMPROJECT")
+      build_id = v.("BUILD_BUILDID")
+      attempt = v.("SYSTEM_STAGEATTEMPT") || "1"
+      build_url = ("#{base}#{ERB::Util.url_encode(project)}/_build/results?buildId=#{build_id}" if base && project && build_id)
+      ids = [base&.sub(%r{\Ahttps?://}i, "")&.chomp("/"), v.("SYSTEM_TEAMPROJECTID"), v.("BUILD_REPOSITORY_ID")]
+      build_key = ("azure_pipelines:#{ids.join('/')}:#{build_id}:#{attempt}" if ids.all? && build_id)
+      repo = v.("BUILD_REPOSITORY_NAME")
+      { "provider" => "azure_pipelines", "build_url" => build_url, "build_id" => build_id, "attempt" => attempt,
+        "job" => v.("SYSTEM_JOBDISPLAYNAME"), "build_key" => build_key,
+        "repository" => (project && repo ? "#{project}/#{repo}" : nil) }.compact
+    end
+
+    def azure_pull_request
+      return nil unless AzureEnv.azure_repos_pr?(@env)
+
+      v = ->(name) { AzureEnv.value(@env, name) }
+      number = Integer(v.("SYSTEM_PULLREQUEST_PULLREQUESTID").to_s, exception: false)
+      base = AzureEnv.strip_heads(v.("SYSTEM_PULLREQUEST_TARGETBRANCH"))
+      head = AzureEnv.strip_heads(v.("SYSTEM_PULLREQUEST_SOURCEBRANCH"))
+      sha = v.("SYSTEM_PULLREQUEST_SOURCECOMMITID")
+      return nil unless number&.positive? && [base, head, sha].all? { |s| s.is_a?(String) && !s.empty? }
+
+      collection = AzureEnv.collection_base(@env)
+      project = v.("SYSTEM_TEAMPROJECT")
+      repo = v.("BUILD_REPOSITORY_NAME")
+      url = if collection && project && repo
+              "#{collection}#{ERB::Util.url_encode(project)}/_git/#{ERB::Util.url_encode(repo)}/pullrequest/#{number}"
+            end
+      { "number" => number, "base_branch" => base, "head_branch" => head, "head_sha" => sha, "url" => url }.compact
+    end
+
     def event
       return @event if defined?(@event)
 
@@ -57,6 +94,7 @@ module RaiderReporter
     end
 
     def pull_request
+      return azure_pull_request if AzureEnv.azure?(@env)
       return nil unless event && PR_EVENTS.include?(@env["GITHUB_EVENT_NAME"])
 
       pr = event["pull_request"]
@@ -69,7 +107,10 @@ module RaiderReporter
       return nil unless number.is_a?(Integer) && number >= 1
       return nil unless [base, head, sha].all? { |v| v.is_a?(String) && !v.empty? }
 
-      { "number" => number, "base_branch" => base, "head_branch" => head, "head_sha" => sha }
+      server = @env["GITHUB_SERVER_URL"].to_s
+      repo = @env["GITHUB_REPOSITORY"].to_s
+      url = ("#{server}/#{repo}/pull/#{number}" unless server.empty? || repo.empty?)
+      { "number" => number, "base_branch" => base, "head_branch" => head, "head_sha" => sha, "url" => url }.compact
     rescue StandardError
       nil
     end
@@ -88,6 +129,8 @@ module RaiderReporter
     end
 
     def branch
+      return azure_branch if AzureEnv.azure?(@env)
+
       head_ref = @env["GITHUB_HEAD_REF"].to_s
       return head_ref unless head_ref.empty?
 
@@ -97,7 +140,18 @@ module RaiderReporter
       local == "HEAD" ? nil : local # "HEAD" means detached, not a branch name
     end
 
+    def azure_branch
+      pr = pull_request
+      name = pr ? pr["head_branch"] : AzureEnv.strip_heads(AzureEnv.value(@env, "BUILD_SOURCEBRANCH"))
+      return name if name
+
+      local = @git.call("rev-parse", "--abbrev-ref", "HEAD")
+      local == "HEAD" ? nil : local
+    end
+
     def sha
+      return AzureEnv.value(@env, "BUILD_SOURCEVERSION") || @git.call("rev-parse", "HEAD") if AzureEnv.azure?(@env)
+
       @env["GITHUB_SHA"] || @git.call("rev-parse", "HEAD")
     end
 

data/lib/raider_reporter/cli.rb

@@ -8,7 +8,13 @@ module RaiderReporter
   class CLI
     MARKER = "<!-- raider-reporter:build-comment -->"
     CONTEXT = "raider/tests"
-    REQUIRED_ENV = %w[GITHUB_TOKEN GITHUB_REPOSITORY GITHUB_EVENT_PATH RAIDER_TOKEN RAIDER_ENDPOINT].freeze
+    GITHUB_REQUIRED_ENV = %w[GITHUB_TOKEN GITHUB_REPOSITORY GITHUB_EVENT_PATH RAIDER_TOKEN RAIDER_ENDPOINT].freeze
+    REQUIRED_ENV = GITHUB_REQUIRED_ENV
+    AZURE_REQUIRED_ENV = %w[SYSTEM_ACCESSTOKEN SYSTEM_COLLECTIONURI SYSTEM_TEAMPROJECTID BUILD_REPOSITORY_ID
+                            RAIDER_TOKEN RAIDER_ENDPOINT].freeze
+    THREAD_STATUS = { "passed" => "closed" }.freeze
+    AZURE_STATES = { "passed" => "succeeded", "failed" => "failed", "incomplete" => "pending" }.freeze
+    TOKEN_HINT = "map it with env: SYSTEM_ACCESSTOKEN: $(System.AccessToken)"
     STATUS_STATES = { "passed" => "success", "failed" => "failure", "incomplete" => "pending" }.freeze
     FALLBACK_DESCRIPTIONS = {
       "passed" => "Raider: tests passed",
@@ -19,10 +25,14 @@ module RaiderReporter
     USAGE = <<~TEXT
       Usage: raider-reporter comment
 
-      Posts (or updates) the Raider build summary as a comment on the current pull request
-      and sets the "#{CONTEXT}" commit status. Intended for GitHub Actions; always exits 0.
+      Posts (or updates) the Raider build summary on the current pull request and sets a status.
+      Intended for GitHub Actions and Azure Pipelines (Azure Repos); always exits 0.
 
-      Environment: #{REQUIRED_ENV.join(', ')} (GITHUB_API_URL optional).
+      GitHub Actions: comment + "#{CONTEXT}" commit status.
+        Environment: #{GITHUB_REQUIRED_ENV.join(', ')} (GITHUB_API_URL optional).
+      Azure Pipelines: one PR thread updated in place + a "raider/tests" PR status.
+        Environment: #{AZURE_REQUIRED_ENV.join(', ')}.
+        Map the token in the pipeline: env: SYSTEM_ACCESSTOKEN: $(System.AccessToken)
     TEXT
 
     def initialize(argv, env: ENV, out: $stdout, err: $stderr)
@@ -48,7 +58,17 @@ module RaiderReporter
     private
 
     def comment
-      missing = REQUIRED_ENV.select { |name| @env[name].to_s.strip.empty? }
+      if @env["GITHUB_ACTIONS"] == "true"
+        github_comment
+      elsif AzureEnv.azure?(@env)
+        azure_comment
+      else
+        notice("skipped: unsupported CI")
+      end
+    end
+
+    def github_comment
+      missing = GITHUB_REQUIRED_ENV.select { |name| @env[name].to_s.strip.empty? }
       return notice("skipped: missing #{missing.join(', ')}") unless missing.empty?
 
       event = GithubEvent.load(@env)
@@ -66,6 +86,61 @@ module RaiderReporter
       notice("comment failed: #{e.class}: #{e.message}")
     end
 
+    def azure_comment
+      missing = AZURE_REQUIRED_ENV.select { |name| AzureEnv.value(@env, name).nil? }
+      return notice(azure_missing_message(missing)) unless missing.empty?
+
+      detector = CiDetector.new(env: @env, git: ->(*) {})
+      pr = detector.git&.dig("pr")
+      return notice("skipped: not an Azure Repos pull request") unless pr
+
+      build_key = detector.ci&.dig("build_key")
+      return notice("skipped: could not determine the build key") unless build_key
+
+      publish_azure(pr, build_key)
+    rescue Comment::AzureClient::Forbidden
+      notice(azure_forbidden_message)
+    rescue StandardError => e
+      notice("comment failed: #{e.class}: #{e.message}")
+    end
+
+    def azure_missing_message(missing)
+      message = "skipped: missing #{missing.join(', ')}"
+      message += "; #{TOKEN_HINT}" if missing.include?("SYSTEM_ACCESSTOKEN")
+      message
+    end
+
+    def publish_azure(pr, build_key)
+      summaries = Comment::SummaryClient.new(endpoint: AzureEnv.value(@env, "RAIDER_ENDPOINT"),
+                                             token: AzureEnv.value(@env, "RAIDER_TOKEN"))
+      summary = summaries.fetch(build_key)
+      return notice("summary unavailable: #{summaries.last_error}") unless summary
+
+      azure = Comment::AzureClient.new(token: AzureEnv.value(@env, "SYSTEM_ACCESSTOKEN"), base_url: azure_pr_url(pr))
+      result = azure.upsert_thread(summary.markdown, MARKER, status: THREAD_STATUS.fetch(summary.state, "active"))
+      azure.set_status(state: AZURE_STATES.fetch(summary.state, "pending"), description: description(summary),
+                       target_url: summary.url)
+      notice("PR thread #{result}: #{pr['url'] || "PR ##{pr['number']}"}")
+    end
+
+    def azure_pr_url(pr)
+      "#{AzureEnv.collection_base(@env)}#{AzureEnv.value(@env, 'SYSTEM_TEAMPROJECTID')}/_apis/git/repositories/" \
+        "#{AzureEnv.value(@env, 'BUILD_REPOSITORY_ID')}/pullRequests/#{pr['number']}"
+    end
+
+    def azure_forbidden_message
+      project = AzureEnv.value(@env, "SYSTEM_TEAMPROJECT") || "<project>"
+      "skipped: the build service cannot write to this PR — grant \"Contribute to pull requests\" to " \
+        "\"#{project} Build Service (#{azure_org})\""
+    end
+
+    def azure_org
+      uri = URI.parse(AzureEnv.collection_base(@env).to_s)
+      uri.host.to_s.end_with?("visualstudio.com") ? uri.host.split(".").first : uri.path.split("/").reject(&:empty?).first
+    rescue URI::InvalidURIError
+      nil
+    end
+
     def publish(pr, build_key)
       summaries = Comment::SummaryClient.new(endpoint: @env["RAIDER_ENDPOINT"], token: @env["RAIDER_TOKEN"])
       summary = summaries.fetch(build_key)

data/lib/raider_reporter/comment/azure_client.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module RaiderReporter
+  module Comment
+    # Minimal Azure DevOps REST client: one Raider thread per pull request, plus a PR status.
+    class AzureClient
+      class Error < StandardError; end
+      # 401/403/404: the build service identity cannot write to this PR.
+      class Forbidden < Error; end
+
+      API_VERSION = "7.1"
+      STATUS_API_VERSION = "7.1" # confirmed in the 7.1 Pull Request Statuses doc; see spec header
+      PROPERTY = "Raider.BuildComment"
+      DESCRIPTION_LIMIT = 140
+
+      def initialize(token:, base_url:, timeout: 30)
+        @token = token
+        @base_url = base_url.to_s.sub(%r{/+\z}, "")
+        @timeout = timeout
+      end
+
+      def upsert_thread(markdown, marker, status:)
+        thread = find_thread(marker)
+        if thread
+          comment_id = thread["comments"].first["id"]
+          request(:patch, "/threads/#{thread['id']}/comments/#{comment_id}", { content: markdown })
+          request(:patch, "/threads/#{thread['id']}", { status: status })
+          :updated
+        else
+          request(:post, "/threads", { comments: [{ parentCommentId: 0, content: markdown, commentType: 1 }],
+                                       status: status,
+                                       properties: { PROPERTY => { "$type" => "System.Int32", "$value" => 1 } } })
+          :created
+        end
+      end
+
+      def set_status(state:, description:, target_url:)
+        request(:post, "/statuses", { state: state, description: description.to_s[0, DESCRIPTION_LIMIT],
+                                      targetUrl: target_url, context: { genre: "raider", name: "tests" } },
+                version: STATUS_API_VERSION)
+        nil
+      end
+
+      private
+
+      def find_thread(marker)
+        list = request(:get, "/threads")
+        threads = list.is_a?(Hash) ? list["value"] : nil
+        raise Error, "unexpected threads response" unless threads.is_a?(Array)
+
+        threads.find { |t| ours?(t, marker) }
+      end
+
+      # Only a property-tagged thread whose live first comment starts with the marker is ours.
+      def ours?(thread, marker)
+        return false unless thread.is_a?(Hash) && thread["properties"].is_a?(Hash) && thread["properties"].key?(PROPERTY)
+        return false unless thread["comments"].is_a?(Array)
+
+        first = thread["comments"].first
+        first.is_a?(Hash) && !first["isDeleted"] && first["content"].to_s.start_with?(marker)
+      end
+
+      def redact(text)
+        @token.to_s.empty? ? text.to_s : text.to_s.gsub(@token.to_s, "[REDACTED]")
+      end
+
+      def request(verb, path, payload = nil, version: nil)
+        uri = URI.parse("#{@base_url}#{path}?api-version=#{version || API_VERSION}")
+        raise Error, "Azure DevOps URL must start with http:// or https://" unless uri.is_a?(URI::HTTP)
+
+        req = build_request(verb, uri, payload)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                                       open_timeout: @timeout, read_timeout: @timeout,
+                                                       write_timeout: @timeout) { |http| http.request(req) }
+        handle(response)
+      rescue Error
+        raise
+      rescue StandardError => e
+        raise Error, redact("#{e.class}: #{e.message}")
+      end
+
+      def build_request(verb, uri, json)
+        klass = { get: Net::HTTP::Get, post: Net::HTTP::Post, patch: Net::HTTP::Patch }.fetch(verb)
+        req = klass.new(uri)
+        req["Authorization"] = "Bearer #{@token}"
+        req["Accept"] = "application/json"
+        req["User-Agent"] = "raider_reporter/#{VERSION}"
+        if json
+          req["Content-Type"] = "application/json"
+          req.body = JSON.generate(json)
+        end
+        req
+      end
+
+      def handle(response)
+        code = response.code.to_i
+        raise Forbidden, "HTTP #{code}" if [401, 403, 404].include?(code)
+        raise Error, "HTTP #{code}: #{redact(response.body.to_s)[0, 200]}" unless (200..299).cover?(code)
+
+        JSON.parse(response.body.to_s)
+      rescue JSON::ParserError
+        raise Error, "Azure DevOps returned invalid JSON"
+      end
+    end
+  end
+end

data/lib/raider_reporter/comment/github_client.rb

@@ -101,7 +101,7 @@ module RaiderReporter
       def handle(response)
         code = response.code.to_i
         raise Forbidden, "HTTP #{code}" if [403, 404].include?(code)
-        raise Error, redact("HTTP #{code}: #{response.body.to_s[0, 200]}") unless (200..299).cover?(code)
+        raise Error, "HTTP #{code}: #{redact(response.body.to_s)[0, 200]}" unless (200..299).cover?(code)
 
         JSON.parse(response.body.to_s)
       rescue JSON::ParserError

data/lib/raider_reporter/configuration.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require "raider_reporter/azure_env"
+
 module RaiderReporter
   class Configuration
     attr_accessor :token, :endpoint, :output_dir, :clean_output_dir, :environment, :max_attachment_bytes
 
     def initialize(env = ENV)
-      @token = env["RAIDER_TOKEN"]
-      @endpoint = env["RAIDER_ENDPOINT"]
+      @token = AzureEnv.value(env, "RAIDER_TOKEN")
+      @endpoint = AzureEnv.value(env, "RAIDER_ENDPOINT")
       @output_dir = "raider-results"
       @clean_output_dir = true
       @environment = {}

data/lib/raider_reporter/shard_detector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "raider_reporter/azure_env"
+
 module RaiderReporter
   # Identifies which slice of a parallel suite this process is.
   class ShardDetector
@@ -9,7 +11,7 @@ module RaiderReporter
     end
 
     def shard
-      index, total, suffix = composed || explicit || parallel_tests
+      index, total, suffix = composed || outer || parallel_tests
       return nil unless index
 
       { "index" => index, "total" => total, "label" => "#{@job || "local"}##{suffix || index}" }
@@ -19,7 +21,7 @@ module RaiderReporter
 
     # A matrix leg that also runs parallel_tests: every process gets a unique index.
     def composed
-      explicit_index, explicit_total = explicit
+      explicit_index, explicit_total = outer
       parallel_index, = parallel_tests
       groups = positive(@env["PARALLEL_TEST_GROUPS"])
       return nil unless explicit_index && parallel_index && groups
@@ -29,6 +31,18 @@ module RaiderReporter
        "#{explicit_index}.#{parallel_index}"]
     end
 
+    def outer
+      explicit || azure_parallel
+    end
+
+    def azure_parallel
+      return nil unless AzureEnv.azure?(@env)
+
+      total = positive(AzureEnv.value(@env, "SYSTEM_TOTALJOBSINPHASE"))
+      index = positive(AzureEnv.value(@env, "SYSTEM_JOBPOSITIONINPHASE"))
+      [index, total] if index && total && total > 1
+    end
+
     def explicit
       index = positive(@env["RAIDER_SHARD_INDEX"])
       [index, positive(@env["RAIDER_SHARD_TOTAL"])] if index

data/lib/raider_reporter/version.rb

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

data/lib/raider_reporter/writers/uploader.rb

@@ -12,6 +12,7 @@ module RaiderReporter
       # Keeps uploads under the server's 50 MB request limit and multipart part limit.
       MAX_UPLOAD_ATTACHMENT_BYTES = 45 * 1024 * 1024
       MAX_UPLOAD_ATTACHMENTS = 1000
+      ERROR_DETAIL_LIMIT = 200
 
       def initialize(config, timeout: 30, warn: RaiderReporter.method(:warn))
         @config = config
@@ -42,7 +43,7 @@ module RaiderReporter
         end
         to_result(response)
       rescue StandardError => e
-        Result.new(ok: false, url: nil, run_id: nil, build_url: nil, error: "#{e.class}: #{e.message}")
+        Result.new(ok: false, url: nil, run_id: nil, build_url: nil, error: redact("#{e.class}: #{e.message}"))
       end
 
       private
@@ -97,10 +98,31 @@ module RaiderReporter
           Result.new(ok: true, url: present(body["url"]), run_id: present(body["run_id"]),
                      build_url: present(build["url"]), error: nil)
         else
-          Result.new(ok: false, url: nil, run_id: nil, build_url: nil, error: "HTTP #{response.code}: #{response.body.to_s[0, 200]}")
+          Result.new(ok: false, url: nil, run_id: nil, build_url: nil, error: error_message(response))
         end
       end
 
+      # One short line: an HTML error page (e.g. a Rails 500) is summarised, anything
+      # else is collapsed to one line, redacted, then cut to ERROR_DETAIL_LIMIT.
+      def error_message(response)
+        text = response.body.to_s.dup.force_encoding(Encoding::UTF_8).scrub
+        detail = if html?(response, text)
+                   "the server returned an HTML error page"
+                 else
+                   redact(text).gsub(/\s+/, " ").strip[0, ERROR_DETAIL_LIMIT]
+                 end
+        detail.empty? ? "HTTP #{response.code}" : "HTTP #{response.code}: #{detail}"
+      end
+
+      def html?(response, text)
+        response["Content-Type"].to_s.include?("html") || text.lstrip.start_with?("<")
+      end
+
+      def redact(text)
+        token = @config.token.to_s
+        token.empty? ? text.to_s : text.to_s.gsub(token, "[REDACTED]")
+      end
+
       def parse_body(text)
         parsed = JSON.parse(text.to_s)
         parsed.is_a?(Hash) ? parsed : {}

data/lib/raider_reporter.rb

@@ -15,6 +15,7 @@ require_relative "raider_reporter/shard_detector"
 require_relative "raider_reporter/writers/uploader"
 require_relative "raider_reporter/comment/summary_client"
 require_relative "raider_reporter/comment/github_client"
+require_relative "raider_reporter/comment/azure_client"
 
 module RaiderReporter
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raider_reporter
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Augustin Gottlieb
@@ -24,9 +24,11 @@ files:
 - README.md
 - exe/raider-reporter
 - lib/raider_reporter.rb
+- lib/raider_reporter/azure_env.rb
 - lib/raider_reporter/ci_detector.rb
 - lib/raider_reporter/cli.rb
 - lib/raider_reporter/collector.rb
+- lib/raider_reporter/comment/azure_client.rb
 - lib/raider_reporter/comment/github_client.rb
 - lib/raider_reporter/comment/summary_client.rb
 - lib/raider_reporter/configuration.rb