fastlane-plugin-sentry_api 0.1.0

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

@@ -0,0 +1,242 @@
+require 'fastlane/action'
+require_relative '../helper/sentry_api_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SENTRY_TTID_DATA = :SENTRY_TTID_DATA
+      SENTRY_TTID_STATUS_CODE = :SENTRY_TTID_STATUS_CODE
+      SENTRY_TTID_JSON = :SENTRY_TTID_JSON
+    end
+
+    # Query Time to Initial Display (TTID) percentiles per screen from the Sentry Events/Discover API.
+    # Returns p50, p75, p95 metrics for each screen transaction, sorted by load count.
+    class SentryTtidPercentilesAction < Action
+      class << self
+        def run(params)
+          auth_token = params[:auth_token]
+          org_slug = params[:org_slug]
+          project_id = params[:project_id]
+
+          query_params = build_query_params(params, project_id)
+
+          UI.message("Fetching TTID percentiles from Sentry (#{query_params[:statsPeriod] || 'custom range'})...")
+
+          response = Helper::SentryApiHelper.get_events(
+            auth_token: auth_token,
+            org_slug: org_slug,
+            params: query_params
+          )
+
+          status_code = response[:status]
+          json = response[:json]
+
+          unless status_code.between?(200, 299)
+            UI.user_error!("Sentry Events API error #{status_code}: #{response[:body]}")
+            return nil
+          end
+
+          result = parse_response(json)
+
+          Actions.lane_context[SharedValues::SENTRY_TTID_STATUS_CODE] = status_code
+          Actions.lane_context[SharedValues::SENTRY_TTID_JSON] = json
+          Actions.lane_context[SharedValues::SENTRY_TTID_DATA] = result
+
+          UI.success("Fetched TTID data for #{result.length} screens")
+          result.first(5).each do |screen|
+            UI.message("  #{screen[:transaction]}: p50=#{screen[:p50]}ms p75=#{screen[:p75]}ms p95=#{screen[:p95]}ms (#{screen[:count]} loads)")
+          end
+
+          result
+        end
+
+        #####################################################
+        # @!group Documentation
+        #####################################################
+
+        def description
+          "Query TTID (Time to Initial Display) percentiles per screen from Sentry"
+        end
+
+        def details
+          [
+            "Queries the Sentry Events/Discover API for Time to Initial Display (TTID) metrics.",
+            "Returns p50, p75, and p95 percentiles per screen transaction, sorted by load count.",
+            "Useful for monitoring app launch performance and screen rendering latency.",
+            "",
+            "Supports filtering by release, environment, and transaction operation type.",
+            "Use `stats_period` for rolling windows or `start_date` + `end_date` for specific ranges.",
+            "",
+            "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),
+            FastlaneCore::ConfigItem.new(key: :transaction_op,
+                                  description: "Transaction operation filter (e.g. 'ui.load', 'ui.action')",
+                                     optional: true,
+                                default_value: "ui.load",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :per_page,
+                                  description: "Number of screens to return (max 100)",
+                                     optional: true,
+                                default_value: 20,
+                                         type: Integer),
+            FastlaneCore::ConfigItem.new(key: :sort,
+                                  description: "Sort order (e.g. '-count()', '-p95(measurements.time_to_initial_display)')",
+                                     optional: true,
+                                default_value: "-count()",
+                                         type: String)
+          ]
+        end
+
+        def output
+          [
+            ['SENTRY_TTID_DATA', 'Array of hashes with :transaction, :p50, :p75, :p95, :count per screen'],
+            ['SENTRY_TTID_STATUS_CODE', 'HTTP status code from the Sentry API'],
+            ['SENTRY_TTID_JSON', 'Raw JSON response from the Sentry API']
+          ]
+        end
+
+        def return_value
+          "An array of hashes, each with :transaction (screen name), :p50, :p75, :p95 (in ms), and :count (number of loads)."
+        end
+
+        def authors
+          ["crazymanish"]
+        end
+
+        def example_code
+          [
+            '# Top 10 screens by load count, last 7 days
+            screens = sentry_ttid_percentiles(stats_period: "7d", per_page: 10)
+            screens.each do |s|
+              UI.message("#{s[:transaction]}: p50=#{s[:p50]}ms p95=#{s[:p95]}ms (#{s[:count]} loads)")
+            end',
+
+            '# Filter by release
+            sentry_ttid_percentiles(release: "v25.10.0", stats_period: "14d")',
+
+            '# Custom date range (for week-over-week comparison)
+            sentry_ttid_percentiles(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)
+          fields = [
+            'transaction',
+            'p50(measurements.time_to_initial_display)',
+            'p75(measurements.time_to_initial_display)',
+            'p95(measurements.time_to_initial_display)',
+            'count()'
+          ]
+
+          # Build the query filter
+          query_parts = ["event.type:transaction"]
+          query_parts << "transaction.op:#{params[:transaction_op]}" if params[:transaction_op]
+          query_parts << "release:#{params[:release]}" if params[:release]
+
+          query_params = {
+            dataset: 'metrics',
+            field: fields,
+            project: project_id.to_s,
+            query: query_parts.join(' '),
+            sort: params[:sort] || '-count()',
+            per_page: (params[:per_page] || 20).to_s
+          }
+
+          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)
+          data = json&.dig('data') || []
+
+          data.map do |row|
+            {
+              transaction: row['transaction'],
+              p50: round_ms(row['p50(measurements.time_to_initial_display)']),
+              p75: round_ms(row['p75(measurements.time_to_initial_display)']),
+              p95: round_ms(row['p95(measurements.time_to_initial_display)']),
+              count: row['count()']
+            }
+          end
+        end
+
+        def round_ms(value)
+          return nil if value.nil?
+
+          value.round(1)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sentry_api/helper/sentry_api_helper.rb

@@ -0,0 +1,113 @@
+require 'fastlane_core/ui/ui'
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class SentryApiHelper
+      BASE_URL = "https://sentry.io/api/0"
+
+      class << self
+        # Make a GET request to the Sentry REST API.
+        #
+        # @param auth_token [String] Sentry auth token (Bearer)
+        # @param path [String] API endpoint path (e.g. "/organizations/my-org/sessions/")
+        # @param params [Hash] Query parameters. Array values produce repeated keys (field=a&field=b).
+        # @param base_url [String] Sentry API base URL
+        # @return [Hash] { status: Integer, body: String, json: Object|nil }
+        def api_request(auth_token:, path:, params: {}, base_url: BASE_URL)
+          url = "#{base_url}#{path}"
+          uri = URI(url)
+          uri.query = build_query_string(params) unless params.nil? || params.empty?
+
+          UI.verbose("Sentry API GET: #{uri}")
+
+          req = Net::HTTP::Get.new(uri)
+          req['Authorization'] = "Bearer #{auth_token}"
+          req['Content-Type'] = 'application/json'
+
+          http = Net::HTTP.new(uri.hostname, uri.port)
+          if uri.scheme == 'https'
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+            # Disable CRL checking to avoid "unable to get certificate CRL" errors
+            cert_store = OpenSSL::X509::Store.new
+            cert_store.set_default_paths
+            http.cert_store = cert_store
+          end
+          http.open_timeout = 30
+          http.read_timeout = 60
+
+          response = http.request(req)
+
+          status_code = response.code.to_i
+          body = response.body.to_s
+          json = parse_json(body)
+
+          { status: status_code, body: body, json: json }
+        end
+
+        # GET /api/0/organizations/{org}/sessions/
+        # Used for crash-free rates, session counts, user counts.
+        def get_sessions(auth_token:, org_slug:, params: {})
+          api_request(
+            auth_token: auth_token,
+            path: "/organizations/#{org_slug}/sessions/",
+            params: params
+          )
+        end
+
+        # GET /api/0/organizations/{org}/events/
+        # Used for Discover queries (TTID percentiles, performance metrics).
+        def get_events(auth_token:, org_slug:, params: {})
+          api_request(
+            auth_token: auth_token,
+            path: "/organizations/#{org_slug}/events/",
+            params: params
+          )
+        end
+
+        # GET /api/0/projects/{org}/{project}/issues/
+        # Used for listing project issues filtered by release, query, etc.
+        def get_issues(auth_token:, org_slug:, project_slug:, params: {})
+          api_request(
+            auth_token: auth_token,
+            path: "/projects/#{org_slug}/#{project_slug}/issues/",
+            params: params
+          )
+        end
+
+        private
+
+        # Build a query string that supports repeated parameter keys via Array values.
+        # Example: { field: ['a', 'b'], project: 1 } => "field=a&field=b&project=1"
+        def build_query_string(params)
+          return nil if params.nil? || params.empty?
+
+          pairs = []
+          params.each do |key, value|
+            next if value.nil?
+
+            if value.is_a?(Array)
+              value.each { |v| pairs << [key.to_s, v.to_s] }
+            else
+              pairs << [key.to_s, value.to_s]
+            end
+          end
+
+          URI.encode_www_form(pairs)
+        end
+
+        def parse_json(value)
+          JSON.parse(value)
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sentry_api/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module SentryApi
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/sentry_api.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/sentry_api/version'
+
+module Fastlane
+  module SentryApi
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::SentryApi.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-sentry_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- crazymanish
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+email: i.am.manish.rathi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/sentry_api.rb
+- lib/fastlane/plugin/sentry_api/actions/sentry_api_action.rb
+- lib/fastlane/plugin/sentry_api/actions/sentry_crash_free_sessions_action.rb
+- lib/fastlane/plugin/sentry_api/actions/sentry_crash_free_users_action.rb
+- lib/fastlane/plugin/sentry_api/actions/sentry_list_issues_action.rb
+- lib/fastlane/plugin/sentry_api/actions/sentry_slo_report_action.rb
+- lib/fastlane/plugin/sentry_api/actions/sentry_ttid_percentiles_action.rb
+- lib/fastlane/plugin/sentry_api/helper/sentry_api_helper.rb
+- lib/fastlane/plugin/sentry_api/version.rb
+homepage: https://github.com/crazymanish/fastlane-plugin-sentry_api
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Fastlane plugin for Sentry APIs - crash-free rates, TTID percentiles, issue
+  tracking, and SLO reports
+test_files: []