fastlane-plugin-sentry_api 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb37a45115a453684dd66170705b0742827ed070a18f78bb11180d8d796b74a0
-  data.tar.gz: b6775dc33d9ff13ca2152efc140fa74aa304e8e31251b9fc10bd3af08f5de4dd
+  metadata.gz: cee8dc5203226fee972dc466c125f43e872f655f4776dc703feb349a638a8ea1
+  data.tar.gz: 8d4f199b0714184b9475043557c0150da47fa83881b09de8e1ebe4b4866187e8
 SHA512:
-  metadata.gz: ce63e72ef9919324c6107a90402407172ecaf58410e8b80b593fec312e6fb844901f8bd5c173574bb6e3a454a3fcdd09b09acfe37fe600c53f839c1af21859d2
-  data.tar.gz: 2cf45d8c19fb2bc24f7ceea371d64ba2b490cb2ffe7cf8e1d2277b006661a9e6a6ef530008d64218f53fdb48b6ba4880c7762f6972ce73a766e7c47e63bb052a
+  metadata.gz: dbbb4b57bf4a3fa1530489172d9c40024e04f2b2c54ceb59ae2c79bc1f63488749528d708c7e31353212fbabf5e16c5a6ed26b893c5a2a96b9c7affed0d920e1
+  data.tar.gz: 1ef24556a924fd1a372e56e8693d8eac3c25295d4a30608cd3c72a5f064c6cc34d0ff8b96739da6cc88495858560cdc570d5fe97148ca9eb8982dde9178f2c62

data/README.md

@@ -21,7 +21,8 @@ A Fastlane plugin providing reusable actions for querying [Sentry](https://sentr
 | [`sentry_api`](#sentry_api) | Generic GET request to any Sentry API endpoint |
 | [`sentry_crash_free_sessions`](#sentry_crash_free_sessions) | Crash-free session & user rates from the Sessions API |
 | [`sentry_crash_free_users`](#sentry_crash_free_users) | User-focused crash-free rate (convenience wrapper) |
-| [`sentry_ttid_percentiles`](#sentry_ttid_percentiles) | TTID p50/p75/p95 per screen from the Discover API |
+| [`sentry_ttid_percentiles`](#sentry_ttid_percentiles) | TTID p50/p75/p95 per screen (+ overall aggregate) from the Discover API |
+| [`sentry_app_launch`](#sentry_app_launch) | App launch latency (cold start & warm start) percentiles |
 | [`sentry_list_issues`](#sentry_list_issues) | Fetch project issues with filtering & sorting |
 | [`sentry_slo_report`](#sentry_slo_report) | Comprehensive SLO report orchestrating all the above |
 
@@ -143,7 +144,7 @@ UI.message("Crash-free users: #{(rate * 100).round(2)}%")
 
 ### `sentry_ttid_percentiles`
 
-Query TTID (Time to Initial Display) percentiles per screen from the Sentry Events/Discover API. Returns p50, p75, p95 per screen transaction, sorted by load count.
+Query TTID (Time to Initial Display) percentiles per screen from the Sentry Events/Discover API. Returns p50, p75, p95 per screen transaction, sorted by load count. Optionally fetches overall/aggregate TTID percentiles across all screens.
 
 **Parameters:**
 
@@ -160,8 +161,9 @@ Query TTID (Time to Initial Display) percentiles per screen from the Sentry Even
 | `transaction_op` | `String` | No | `ui.load` | Transaction operation filter |
 | `per_page` | `Integer` | No | `20` | Number of screens to return (max 100) |
 | `sort` | `String` | No | `-count()` | Sort order |
+| `include_overall` | `Boolean` | No | `false` | Also fetch overall/aggregate TTID percentiles across all screens |
 
-**Output (SharedValues):** `SENTRY_TTID_DATA` (array of `{ transaction:, p50:, p75:, p95:, count: }`)
+**Output (SharedValues):** `SENTRY_TTID_DATA` (array of `{ transaction:, p50:, p75:, p95:, count: }`), `SENTRY_TTID_OVERALL` (hash with `{ p50:, p75:, p95:, count: }` when `include_overall` is true)
 
 **Examples:**
 
@@ -172,6 +174,11 @@ screens.each do |s|
   UI.message("#{s[:transaction]}: p50=#{s[:p50]}ms p95=#{s[:p95]}ms (#{s[:count]} loads)")
 end
 
+# With overall aggregate TTID
+screens = sentry_ttid_percentiles(stats_period: "7d", per_page: 10, include_overall: true)
+overall = lane_context[SharedValues::SENTRY_TTID_OVERALL]
+UI.message("Overall TTID: p50=#{overall[:p50]}ms p95=#{overall[:p95]}ms") if overall
+
 # Filter by release
 sentry_ttid_percentiles(release: "v25.10.0", stats_period: "14d")
 
@@ -184,6 +191,47 @@ sentry_ttid_percentiles(
 
 ---
 
+### `sentry_app_launch`
+
+Query app launch latency (cold start & warm start) percentiles from the Sentry Events/Discover API. Uses Sentry's `measurements.app_start_cold` and `measurements.app_start_warm` fields.
+
+**Parameters:**
+
+| Key | Type | Required | Default | Description |
+|-----|------|----------|---------|-------------|
+| `auth_token` | `String` | Yes | `SENTRY_AUTH_TOKEN` | API Bearer auth token |
+| `org_slug` | `String` | Yes | `SENTRY_ORG_SLUG` | Organization slug |
+| `project_id` | `String` | Yes | `SENTRY_PROJECT_ID` | Numeric project ID |
+| `environment` | `String` | No | `production` | Environment filter |
+| `stats_period` | `String` | No | `7d` | Rolling window |
+| `start_date` | `String` | No | — | ISO 8601 start date |
+| `end_date` | `String` | No | — | ISO 8601 end date |
+| `release` | `String` | No | — | Filter by release version |
+
+**Output (SharedValues):** `SENTRY_APP_LAUNCH_DATA` (hash with `:cold_start` and `:warm_start`, each containing `{ p50:, p75:, p95:, count: }`)
+
+**Examples:**
+
+```ruby
+# Fetch app launch metrics for the last 7 days
+result = sentry_app_launch(stats_period: "7d")
+cold = result[:cold_start]
+warm = result[:warm_start]
+UI.message("Cold start: p50=#{cold[:p50]}ms p95=#{cold[:p95]}ms (#{cold[:count]} launches)")
+UI.message("Warm start: p50=#{warm[:p50]}ms p95=#{warm[:p95]}ms (#{warm[:count]} launches)")
+
+# Filter by release
+sentry_app_launch(release: "v25.10.0", stats_period: "14d")
+
+# Custom date range
+sentry_app_launch(
+  start_date: "2026-02-24T00:00:00Z",
+  end_date: "2026-03-03T00:00:00Z"
+)
+```
+
+---
+
 ### `sentry_list_issues`
 
 Fetch issues from a Sentry project. Supports filtering by release version, query string, sort order, and pagination. Useful for comparing issues across releases.
@@ -226,8 +274,10 @@ sentry_list_issues(query: "is:unresolved first-release:v25.10.0", sort: "date")
 Generate a comprehensive SLO report by orchestrating multiple Sentry API calls. Produces a structured report with:
 
 - **Availability** — Crash-free session/user rates with week-over-week delta
-- **Latency** — TTID p50/p75/p95 per screen with week-over-week delta
+- **Latency (TTID)** — Overall/aggregate TTID percentiles + per-screen p50/p75/p95 with week-over-week delta
+- **Latency (App Launch)** — Cold start & warm start percentiles with week-over-week delta
 - **Release comparison** — Release-over-release crash-free rates
+- **Top Crash Issues** — Top unhandled error issues by frequency (`is:unresolved issue.category:error error.unhandled:true`)
 - **Issues** — Issue counts and top issues per release (latest vs previous)
 
 Includes target checking with ✅/⚠️ indicators and optional JSON file output.
@@ -244,6 +294,7 @@ Includes target checking with ✅/⚠️ indicators and optional JSON file outpu
 | `stats_period` | `String` | No | `7d` | Rolling window |
 | `crash_free_target` | `Float` | No | `0.998` | Target crash-free session rate (e.g. 0.998 = 99.8%) |
 | `ttid_p95_target_ms` | `Integer` | No | `1000` | Target TTID p95 in milliseconds |
+| `app_launch_p95_target_ms` | `Integer` | No | `2000` | Target app launch (cold start) p95 in milliseconds |
 | `compare_weeks` | `Boolean` | No | `true` | Include week-over-week comparison |
 | `compare_releases` | `Boolean` | No | `true` | Include release-over-release comparison |
 | `current_release` | `String` | No | — | Current release version for issue comparison |
@@ -251,10 +302,22 @@ Includes target checking with ✅/⚠️ indicators and optional JSON file outpu
 | `release_count` | `Integer` | No | `5` | Number of releases to compare |
 | `ttid_screen_count` | `Integer` | No | `10` | Number of top screens in TTID report |
 | `issue_count` | `Integer` | No | `10` | Number of top issues per release |
+| `crash_issue_count` | `Integer` | No | `5` | Number of top crash (unhandled error) issues to include |
 | `output_json` | `String` | No | — | Path to write JSON report file |
 
 **Output (SharedValues):** `SENTRY_SLO_REPORT` (complete hash with `:availability`, `:latency`, `:issues`)
 
+The `:latency` section includes:
+- `:current` — array of per-screen TTID data
+- `:overall` — aggregate TTID `{ p50:, p75:, p95:, count: }` across all screens
+- `:app_launch` — `{ cold: { p50:, p75:, p95:, count: }, warm: { ... } }`
+- `:previous`, `:overall_previous`, `:app_launch_previous` — week-over-week counterparts (when `compare_weeks` is true)
+
+The `:issues` section includes:
+- `:top_crashes` — array of top unhandled error issues (always fetched, not release-scoped)
+- `:current_release` — `{ version:, count:, issues: [] }` (when `current_release` is provided)
+- `:previous_release` — same structure (when `previous_release` is provided)
+
 **Examples:**
 
 ```ruby
@@ -262,6 +325,7 @@ Includes target checking with ✅/⚠️ indicators and optional JSON file outpu
 sentry_slo_report(
   crash_free_target: 0.998,
   ttid_p95_target_ms: 1000,
+  app_launch_p95_target_ms: 2000,
   compare_weeks: true,
   compare_releases: true,
   current_release: "v25.10.0",
@@ -269,6 +333,22 @@ sentry_slo_report(
   output_json: "slo_report.json"
 )
 
+# Access report data
+report = lane_context[SharedValues::SENTRY_SLO_REPORT]
+
+# Overall TTID
+overall = report[:latency][:overall]
+UI.message("Overall TTID p95: #{overall[:p95]}ms")
+
+# App launch
+cold = report[:latency][:app_launch][:cold]
+UI.message("Cold start p95: #{cold[:p95]}ms")
+
+# Top crash issues
+report[:issues][:top_crashes].each do |issue|
+  UI.message("#{issue[:short_id]}: #{issue[:title]} (#{issue[:event_count]} events)")
+end
+
 # Quick availability check only
 report = sentry_slo_report(
   compare_weeks: true,
@@ -292,10 +372,29 @@ lane :availability_check do
   UI.important("Crash-free session rate: #{(rate * 100).round(2)}%")
 end
 
+lane :ttid_check do
+  screens = sentry_ttid_percentiles(stats_period: "7d", per_page: 10, include_overall: true)
+  screens.each do |s|
+    UI.message("#{s[:transaction]}: p50=#{s[:p50]}ms p95=#{s[:p95]}ms (#{s[:count]} loads)")
+  end
+
+  overall = lane_context[SharedValues::SENTRY_TTID_OVERALL]
+  UI.important("Overall TTID: p50=#{overall[:p50]}ms p95=#{overall[:p95]}ms") if overall
+end
+
+lane :app_launch_check do
+  result = sentry_app_launch(stats_period: "7d")
+  cold = result[:cold_start]
+  warm = result[:warm_start]
+  UI.message("Cold start: p50=#{cold[:p50]}ms p95=#{cold[:p95]}ms")
+  UI.message("Warm start: p50=#{warm[:p50]}ms p95=#{warm[:p95]}ms")
+end
+
 lane :slo_report do
   sentry_slo_report(
     crash_free_target: 0.998,
     ttid_p95_target_ms: 1000,
+    app_launch_p95_target_ms: 2000,
     current_release: "v25.10.0",
     previous_release: "v25.9.0",
     output_json: "slo_report.json"

data/lib/fastlane/plugin/sentry_api/actions/sentry_api_action.rb

@@ -59,32 +59,32 @@ module Fastlane
         def available_options
           [
             FastlaneCore::ConfigItem.new(key: :auth_token,
-                                     env_name: "SENTRY_AUTH_TOKEN",
-                                  description: "Sentry API Bearer auth token",
-                                     optional: false,
+                                         env_name: "SENTRY_AUTH_TOKEN",
+                                         description: "Sentry API Bearer auth token",
+                                         optional: false,
                                          type: String,
-                                    sensitive: true,
-                           code_gen_sensitive: true,
-                                verify_block: proc do |value|
-                                                UI.user_error!("No Sentry auth token given, pass using `auth_token: 'token'`") if value.to_s.empty?
-                                              end),
+                                         sensitive: true,
+                                         code_gen_sensitive: true,
+                                         verify_block: proc do |value|
+                                                         UI.user_error!("No Sentry auth token given, pass using `auth_token: 'token'`") if value.to_s.empty?
+                                                       end),
             FastlaneCore::ConfigItem.new(key: :server_url,
-                                     env_name: "SENTRY_API_SERVER_URL",
-                                  description: "Sentry API base URL",
-                                     optional: true,
-                                default_value: "https://sentry.io/api/0",
+                                         env_name: "SENTRY_API_SERVER_URL",
+                                         description: "Sentry API base URL",
+                                         optional: true,
+                                         default_value: "https://sentry.io/api/0",
                                          type: String),
             FastlaneCore::ConfigItem.new(key: :path,
-                                  description: "API endpoint path (e.g. '/organizations/my-org/sessions/')",
-                                     optional: false,
+                                         description: "API endpoint path (e.g. '/organizations/my-org/sessions/')",
+                                         optional: false,
                                          type: String,
-                                verify_block: proc do |value|
-                                                UI.user_error!("API path cannot be empty") if value.to_s.empty?
-                                              end),
+                                         verify_block: proc do |value|
+                                                         UI.user_error!("API path cannot be empty") if value.to_s.empty?
+                                                       end),
             FastlaneCore::ConfigItem.new(key: :params,
-                                  description: "Query parameters hash. Array values produce repeated keys.",
-                                     optional: true,
-                                default_value: {},
+                                         description: "Query parameters hash. Array values produce repeated keys.",
+                                         optional: true,
+                                         default_value: {},
                                          type: Hash)
           ]
         end

data/lib/fastlane/plugin/sentry_api/actions/sentry_app_launch_action.rb

@@ -0,0 +1,260 @@
+require 'fastlane/action'
+require_relative '../helper/sentry_api_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SENTRY_APP_LAUNCH_DATA = :SENTRY_APP_LAUNCH_DATA
+      SENTRY_APP_LAUNCH_STATUS_CODE = :SENTRY_APP_LAUNCH_STATUS_CODE
+      SENTRY_APP_LAUNCH_JSON = :SENTRY_APP_LAUNCH_JSON
+    end
+
+    # Query app launch (cold start & warm start) percentiles from the Sentry Events/Discover API.
+    # Returns p50, p75, p95 metrics for cold start and warm start durations.
+    class SentryAppLaunchAction < Action
+      class << self
+        def run(params)
+          auth_token = params[:auth_token]
+          org_slug = params[:org_slug]
+          project_id = params[:project_id]
+
+          result = {}
+
+          # Fetch cold start metrics
+          cold_params = build_query_params(params, project_id, :cold)
+          UI.message("Fetching cold start metrics from Sentry (#{cold_params[:statsPeriod] || 'custom range'})...")
+
+          cold_response = Helper::SentryApiHelper.get_events(
+            auth_token: auth_token,
+            org_slug: org_slug,
+            params: cold_params
+          )
+
+          unless cold_response[:status].between?(200, 299)
+            UI.user_error!("Sentry Events API error #{cold_response[:status]}: #{cold_response[:body]}")
+            return nil
+          end
+
+          result[:cold_start] = parse_response(cold_response[:json], :cold)
+
+          # Fetch warm start metrics
+          warm_params = build_query_params(params, project_id, :warm)
+          UI.message("Fetching warm start metrics from Sentry...")
+
+          warm_response = Helper::SentryApiHelper.get_events(
+            auth_token: auth_token,
+            org_slug: org_slug,
+            params: warm_params
+          )
+
+          unless warm_response[:status].between?(200, 299)
+            UI.user_error!("Sentry Events API error #{warm_response[:status]}: #{warm_response[:body]}")
+            return nil
+          end
+
+          result[:warm_start] = parse_response(warm_response[:json], :warm)
+
+          Actions.lane_context[SharedValues::SENTRY_APP_LAUNCH_STATUS_CODE] = cold_response[:status]
+          Actions.lane_context[SharedValues::SENTRY_APP_LAUNCH_JSON] = {
+            cold: cold_response[:json],
+            warm: warm_response[:json]
+          }
+          Actions.lane_context[SharedValues::SENTRY_APP_LAUNCH_DATA] = result
+
+          log_result(result)
+
+          result
+        end
+
+        #####################################################
+        # @!group Documentation
+        #####################################################
+
+        def description
+          "Query app launch (cold start & warm start) latency percentiles from Sentry"
+        end
+
+        def details
+          [
+            "Queries the Sentry Events/Discover API for app launch latency metrics.",
+            "Returns p50, p75, and p95 percentiles for both cold start and warm start durations.",
+            "",
+            "Cold start: Full app initialization from a terminated state.",
+            "Warm start: App resume from a backgrounded/cached state.",
+            "",
+            "Uses Sentry's `measurements.app_start_cold` and `measurements.app_start_warm` fields.",
+            "Supports filtering by release, environment, and time range.",
+            "",
+            "API Documentation: https://docs.sentry.io/api/discover/"
+          ].join("\n")
+        end
+
+        def available_options
+          [
+            FastlaneCore::ConfigItem.new(key: :auth_token,
+                                         env_name: "SENTRY_AUTH_TOKEN",
+                                         description: "Sentry API Bearer auth token",
+                                         optional: false,
+                                         type: String,
+                                         sensitive: true,
+                                         code_gen_sensitive: true,
+                                         verify_block: proc do |value|
+                                                         UI.user_error!("No Sentry auth token given, pass using `auth_token: 'token'`") if value.to_s.empty?
+                                                       end),
+            FastlaneCore::ConfigItem.new(key: :org_slug,
+                                         env_name: "SENTRY_ORG_SLUG",
+                                         description: "Sentry organization slug",
+                                         optional: false,
+                                         type: String,
+                                         verify_block: proc do |value|
+                                                         UI.user_error!("No Sentry org slug given, pass using `org_slug: 'my-org'`") if value.to_s.empty?
+                                                       end),
+            FastlaneCore::ConfigItem.new(key: :project_id,
+                                         env_name: "SENTRY_PROJECT_ID",
+                                         description: "Sentry numeric project ID",
+                                         optional: false,
+                                         type: String,
+                                         verify_block: proc do |value|
+                                                         UI.user_error!("No Sentry project ID given, pass using `project_id: '12345'`") if value.to_s.empty?
+                                                       end),
+            FastlaneCore::ConfigItem.new(key: :environment,
+                                         env_name: "SENTRY_ENVIRONMENT",
+                                         description: "Environment filter (e.g. 'production')",
+                                         optional: true,
+                                         default_value: "production",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :stats_period,
+                                         description: "Rolling time window (e.g. '7d', '14d', '30d')",
+                                         optional: true,
+                                         default_value: "7d",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :start_date,
+                                         description: "Start date in ISO 8601 format. Use with end_date instead of stats_period",
+                                         optional: true,
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :end_date,
+                                         description: "End date in ISO 8601 format. Use with start_date instead of stats_period",
+                                         optional: true,
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :release,
+                                         description: "Filter by specific release version",
+                                         optional: true,
+                                         type: String)
+          ]
+        end
+
+        def output
+          [
+            ['SENTRY_APP_LAUNCH_DATA', 'Hash with :cold_start and :warm_start, each containing :p50, :p75, :p95, :count'],
+            ['SENTRY_APP_LAUNCH_STATUS_CODE', 'HTTP status code from the Sentry API'],
+            ['SENTRY_APP_LAUNCH_JSON', 'Raw JSON responses from the Sentry API (cold and warm)']
+          ]
+        end
+
+        def return_value
+          "A hash with :cold_start and :warm_start keys, each containing :p50, :p75, :p95 (in ms), and :count."
+        end
+
+        def authors
+          ["crazymanish"]
+        end
+
+        def example_code
+          [
+            '# Fetch app launch metrics for the last 7 days
+            result = sentry_app_launch(stats_period: "7d")
+            cold = result[:cold_start]
+            warm = result[:warm_start]
+            UI.message("Cold start: p50=#{cold[:p50]}ms p95=#{cold[:p95]}ms")
+            UI.message("Warm start: p50=#{warm[:p50]}ms p95=#{warm[:p95]}ms")',
+
+            '# Filter by release
+            sentry_app_launch(release: "v25.10.0", stats_period: "14d")',
+
+            '# Custom date range
+            sentry_app_launch(start_date: "2026-02-24T00:00:00Z", end_date: "2026-03-03T00:00:00Z")'
+          ]
+        end
+
+        def category
+          :misc
+        end
+
+        def is_supported?(platform)
+          true
+        end
+
+        private
+
+        def build_query_params(params, project_id, start_type)
+          measurement = start_type == :cold ? 'app_start_cold' : 'app_start_warm'
+
+          fields = [
+            "p50(measurements.#{measurement})",
+            "p75(measurements.#{measurement})",
+            "p95(measurements.#{measurement})",
+            'count()'
+          ]
+
+          query_parts = ['event.type:transaction']
+          query_parts << "has:measurements.#{measurement}"
+          query_parts << "release:#{params[:release]}" if params[:release]
+
+          query_params = {
+            dataset: 'metrics',
+            field: fields,
+            project: project_id.to_s,
+            query: query_parts.join(' '),
+            per_page: '1'
+          }
+
+          if params[:start_date] && params[:end_date]
+            query_params[:start] = params[:start_date]
+            query_params[:end] = params[:end_date]
+          else
+            query_params[:statsPeriod] = params[:stats_period] || '7d'
+          end
+
+          query_params[:environment] = params[:environment] if params[:environment]
+
+          query_params
+        end
+
+        def parse_response(json, start_type)
+          measurement = start_type == :cold ? 'app_start_cold' : 'app_start_warm'
+          row = json&.dig('data', 0) || {}
+
+          {
+            p50: round_ms(row["p50(measurements.#{measurement})"]),
+            p75: round_ms(row["p75(measurements.#{measurement})"]),
+            p95: round_ms(row["p95(measurements.#{measurement})"]),
+            count: row['count()']
+          }
+        end
+
+        def round_ms(value)
+          return nil if value.nil?
+
+          value.round(1)
+        end
+
+        def log_result(result)
+          cold = result[:cold_start]
+          warm = result[:warm_start]
+
+          if cold[:p50]
+            UI.success("Cold start: p50=#{cold[:p50]}ms p75=#{cold[:p75]}ms p95=#{cold[:p95]}ms (#{cold[:count]} launches)")
+          else
+            UI.message("Cold start: no data available")
+          end
+
+          if warm[:p50]
+            UI.success("Warm start: p50=#{warm[:p50]}ms p75=#{warm[:p75]}ms p95=#{warm[:p95]}ms (#{warm[:count]} launches)")
+          else
+            UI.message("Warm start: no data available")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sentry_api/actions/sentry_crash_free_sessions_action.rb

@@ -92,63 +92,63 @@ module Fastlane
         def available_options
           [
             FastlaneCore::ConfigItem.new(key: :auth_token,
-                                     env_name: "SENTRY_AUTH_TOKEN",
-                                  description: "Sentry API Bearer auth token",
-                                     optional: false,
+                                         env_name: "SENTRY_AUTH_TOKEN",
+                                         description: "Sentry API Bearer auth token",
+                                         optional: false,
                                          type: String,
-                                    sensitive: true,
-                           code_gen_sensitive: true,
-                                verify_block: proc do |value|
-                                                UI.user_error!("No Sentry auth token given, pass using `auth_token: 'token'`") if value.to_s.empty?
-                                              end),
+                                         sensitive: true,
+                                         code_gen_sensitive: true,
+                                         verify_block: proc do |value|
+                                                         UI.user_error!("No Sentry auth token given, pass using `auth_token: 'token'`") if value.to_s.empty?
+                                                       end),
             FastlaneCore::ConfigItem.new(key: :org_slug,
-                                     env_name: "SENTRY_ORG_SLUG",
-                                  description: "Sentry organization slug",
-                                     optional: false,
+                                         env_name: "SENTRY_ORG_SLUG",
+                                         description: "Sentry organization slug",
+                                         optional: false,
                                          type: String,
-                                verify_block: proc do |value|
-                                                UI.user_error!("No Sentry org slug given, pass using `org_slug: 'my-org'`") if value.to_s.empty?
-                                              end),
+                                         verify_block: proc do |value|
+                                                         UI.user_error!("No Sentry org slug given, pass using `org_slug: 'my-org'`") if value.to_s.empty?
+                                                       end),
             FastlaneCore::ConfigItem.new(key: :project_id,
-                                     env_name: "SENTRY_PROJECT_ID",
-                                  description: "Sentry numeric project ID",
-                                     optional: false,
+                                         env_name: "SENTRY_PROJECT_ID",
+                                         description: "Sentry numeric project ID",
+                                         optional: false,
                                          type: String,
-                                verify_block: proc do |value|
-                                                UI.user_error!("No Sentry project ID given, pass using `project_id: '12345'`") if value.to_s.empty?
-                                              end),
+                                         verify_block: proc do |value|
+                                                         UI.user_error!("No Sentry project ID given, pass using `project_id: '12345'`") if value.to_s.empty?
+                                                       end),
             FastlaneCore::ConfigItem.new(key: :environment,
-                                     env_name: "SENTRY_ENVIRONMENT",
-                                  description: "Environment filter (e.g. 'production')",
-                                     optional: true,
-                                default_value: "production",
+                                         env_name: "SENTRY_ENVIRONMENT",
+                                         description: "Environment filter (e.g. 'production')",
+                                         optional: true,
+                                         default_value: "production",
                                          type: String),
             FastlaneCore::ConfigItem.new(key: :stats_period,
-                                  description: "Rolling time window (e.g. '7d', '14d', '30d'). Mutually exclusive with start_date/end_date",
-                                     optional: true,
-                                default_value: "7d",
+                                         description: "Rolling time window (e.g. '7d', '14d', '30d'). Mutually exclusive with start_date/end_date",
+                                         optional: true,
+                                         default_value: "7d",
                                          type: String),
             FastlaneCore::ConfigItem.new(key: :start_date,
-                                  description: "Start date in ISO 8601 format (e.g. '2026-03-01T00:00:00Z'). Use with end_date instead of stats_period",
-                                     optional: true,
+                                         description: "Start date in ISO 8601 format (e.g. '2026-03-01T00:00:00Z'). Use with end_date instead of stats_period",
+                                         optional: true,
                                          type: String),
             FastlaneCore::ConfigItem.new(key: :end_date,
-                                  description: "End date in ISO 8601 format (e.g. '2026-03-08T00:00:00Z'). Use with start_date instead of stats_period",
-                                     optional: true,
+                                         description: "End date in ISO 8601 format (e.g. '2026-03-08T00:00:00Z'). Use with start_date instead of stats_period",
+                                         optional: true,
                                          type: String),
             FastlaneCore::ConfigItem.new(key: :group_by,
-                                  description: "Group results by dimension: 'release', 'environment', or nil for aggregate",
-                                     optional: true,
+                                         description: "Group results by dimension: 'release', 'environment', or nil for aggregate",
+                                         optional: true,
                                          type: String),
             FastlaneCore::ConfigItem.new(key: :per_page,
-                                  description: "Number of groups to return when group_by is set (max 100)",
-                                     optional: true,
-                                default_value: 10,
+                                         description: "Number of groups to return when group_by is set (max 100)",
+                                         optional: true,
+                                         default_value: 10,
                                          type: Integer),
             FastlaneCore::ConfigItem.new(key: :order_by,
-                                  description: "Sort order for grouped results (e.g. '-sum(session)', '-crash_free_rate(session)')",
-                                     optional: true,
-                                default_value: "-sum(session)",
+                                         description: "Sort order for grouped results (e.g. '-sum(session)', '-crash_free_rate(session)')",
+                                         optional: true,
+                                         default_value: "-sum(session)",
                                          type: String)
           ]
         end