issue-db 0.1.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 582972c64b6a5a2eb81cec43a2de4c02dffaa18ce6c7b95e533ff2e70d7d2eca
-  data.tar.gz: 1d9bca31c37ae4327d3c36a8f955b63a26bc80e38841b770c710b61906b58f1d
+  metadata.gz: 6f4349ba13a8c9f2971aae3c557c6bcd8d0b1b3fc51ecb4a901e3db2a30538db
+  data.tar.gz: a59e1724a2f9068bd4596a311b051224ad48a8df158e0607f5dc51374f096033
 SHA512:
-  metadata.gz: 55d3dc07637b3e87aa43ce0dd33aaa1e05be8ddf4c9e4cf9d8a4628146fd2ac3538fee93c2345149c89ed9bb4545285eaa394bb4a407802905a75dc5d4c3691d
-  data.tar.gz: e0e3efa9d9120b0e139953a51ba7931db990f52cc05e4eb573a84fcb3bf93fb0536c6447ee638a9cdafbff52c3513f50e429e1cc68a154f141ece1f6dd5b5a17
+  metadata.gz: e64935039edab751270a2fe8d924d32fff52035364baaa0a6455cf2fd0931fd4c51d39164b283435646c44cde628d3fb5cd98908673d8a1c0138a028855750d3
+  data.tar.gz: 28e242676837588f0dbadf5dc831569bc26e703d2533938daebe62e0eb45d59c3d243d8678d4f91dd03baeba371f40cc3272a4290d23af6b6bafd88aac8b2976

data/README.md

@@ -186,8 +186,10 @@ This section will go into detail around how you can configure the `issue-db` gem
 | `LOG_LEVEL` | The log level to use for the `issue-db` gem. Can be one of `DEBUG`, `INFO`, `WARN`, `ERROR`, or `FATAL` | `INFO` |
 | `ISSUE_DB_LABEL` | The label to use for the issues that are used as records in the database. This value is required and it is what this gem uses to scan a repo for the records it is aware of. | `issue-db` |
 | `ISSUE_DB_CACHE_EXPIRY` | The number of seconds to cache the database in memory. The database is cached in memory to avoid making a request to the GitHub API for every operation. The default value is 60 seconds. | `60` |
-| `ISSUE_DB_SLEEP` | The number of seconds to sleep between requests to the GitHub API in the event of an error | `3` |
-| `ISSUE_DB_RETRIES` | The number of retries to make when there is an error making a request to the GitHub API | `10` |
+| `GH_APP_SLEEP` | The number of seconds to sleep between requests to the GitHub API in the event of an error | `3` |
+| `GH_APP_RETRIES` | The number of retries to make when there is an error making a request to the GitHub API | `10` |
+| `GH_APP_EXPONENTIAL_BACKOFF` | Whether to use exponential backoff for retries. When `true`, sleep time doubles with each retry. When `false`, uses fixed sleep time. | `false` |
+| `GH_APP_ALGO` | The algo to use for your GitHub App if providing a private key | `RS256` |
 | `ISSUE_DB_GITHUB_TOKEN` | The GitHub personal access token to use for authenticating with the GitHub API. You can also use a GitHub app or pass in your own authenticated Octokit.rb instance | `nil` |
 
 ## Authentication 🔒

data/issue-db.gemspec

@@ -21,10 +21,9 @@ Gem::Specification.new do |spec|
   }
 
   spec.add_dependency "redacting-logger", "~> 1.4"
-  spec.add_dependency "retryable", "~> 3.0", ">= 3.0.5"
-  spec.add_dependency "octokit", "~> 9.2"
+  spec.add_dependency "octokit", ">= 9.2", "< 11.0"
   spec.add_dependency "faraday-retry", "~> 2.2", ">= 2.2.1"
-  spec.add_dependency "jwt", "~> 2.9", ">= 2.9.3"
+  spec.add_dependency "jwt", ">= 2.9.3", "< 4.0"
 
   spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 

data/lib/issue_db/authentication.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "octokit"
-require_relative "utils/github_app"
+require_relative "utils/github"
 
 class AuthenticationError < StandardError; end
 
@@ -16,9 +16,12 @@ module Authentication
     # if the client is nil, check for GitHub App env vars first
     # first, check if all three of the following env vars are set and have values
     # ISSUE_DB_GITHUB_APP_ID, ISSUE_DB_GITHUB_APP_INSTALLATION_ID, ISSUE_DB_GITHUB_APP_KEY
-    if ENV.fetch("ISSUE_DB_GITHUB_APP_ID", nil) && ENV.fetch("ISSUE_DB_GITHUB_APP_INSTALLATION_ID", nil) && ENV.fetch("ISSUE_DB_GITHUB_APP_KEY", nil)
+    app_id = ENV.fetch("ISSUE_DB_GITHUB_APP_ID", nil)
+    installation_id = ENV.fetch("ISSUE_DB_GITHUB_APP_INSTALLATION_ID", nil)
+    app_key = ENV.fetch("ISSUE_DB_GITHUB_APP_KEY", nil)
+    if app_id && installation_id && app_key
       log.debug("using github app authentication") if log
-      return GitHubApp.new
+      return GitHub.new(log:, app_id:, installation_id:, app_key:)
     end
 
     # if the client is nil and no GitHub App env vars were found, check for the ISSUE_DB_GITHUB_TOKEN

data/lib/issue_db/cache.rb

@@ -11,22 +11,18 @@ module Cache
 
     search_response = nil
     begin
-      Retryable.with_context(:default) do
-        wait_for_rate_limit!(:search) # specifically wait for the search rate limit as it is much lower
-
-        begin
-          # issues structure: { "total_count": 0, "incomplete_results": false, "items": [<issues>] }
-          search_response = @client.search_issues(query)
-        rescue StandardError => e
-          # re-raise the error but if its a secondary rate limit error, just sleep for minute (oof)
-          sleep(60) if e.message.include?("exceeded a secondary rate limit")
-          raise e
-        end
-      end
+      # issues structure: { "total_count": 0, "incomplete_results": false, "items": [<issues>] }
+      search_response = @client.search_issues(query)
     rescue StandardError => e
-      retry_err_msg = "error search_issues() call: #{e.message} - ran out of retries"
+      retry_err_msg = "error search_issues() call: #{e.message}"
       @log.error(retry_err_msg)
-      raise retry_err_msg
+      raise StandardError, retry_err_msg
+    end
+
+    # Safety check to ensure search_response and items are not nil
+    if search_response.nil? || search_response.items.nil?
+      @log.error("search_issues returned nil response or nil items")
+      raise StandardError, "search_issues returned invalid response"
     end
 
     @log.debug("issue cache updated - cached #{search_response.total_count} issues")

data/lib/issue_db/database.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "cache"
-require_relative "utils/throttle"
 require_relative "models/record"
 require_relative "utils/generate"
 
@@ -9,7 +8,6 @@ class RecordNotFound < StandardError; end
 
 class Database
   include Cache
-  include Throttle
   include Generate
 
   # :param: log [Logger] a logger object to use for logging
@@ -24,7 +22,6 @@ class Database
     @repo = repo
     @label = label
     @cache_expiry = cache_expiry
-    @rate_limit_all = nil
     @issues = nil
     @issues_last_updated = nil
   end
@@ -52,13 +49,13 @@ class Database
     body = generate(data, body_before: options[:body_before], body_after: options[:body_after])
 
     # if we make it here, no existing issues were found so we can safely create one
-    issue = Retryable.with_context(:default) do
-      wait_for_rate_limit!
-      @client.create_issue(@repo.full_name, key, body, { labels: @label })
-    end
+    issue = @client.create_issue(@repo.full_name, key, body, { labels: @label })
 
-    # append the newly created issue to the issues cache
-    @issues << issue
+    # ensure the cache is initialized before appending and handle race conditions
+    current_issues = issues
+    if current_issues && !current_issues.include?(issue)
+      @issues << issue
+    end
 
     @log.debug("issue created: #{key}")
     return Record.new(issue)
@@ -92,13 +89,17 @@ class Database
 
     body = generate(data, body_before: options[:body_before], body_after: options[:body_after])
 
-    updated_issue = Retryable.with_context(:default) do
-      wait_for_rate_limit!
-      @client.update_issue(@repo.full_name, issue.number, key, body)
-    end
+    updated_issue = @client.update_issue(@repo.full_name, issue.number, key, body)
 
     # update the issue in the cache using the reference we have
-    @issues[@issues.index(issue)] = updated_issue
+    index = @issues.index(issue)
+    if index
+      @issues[index] = updated_issue
+    else
+      @log.warn("issue not found in cache during update: #{key}")
+      # Force a cache refresh to ensure consistency
+      update_issue_cache!
+    end
 
     @log.debug("issue updated: #{key}")
     return Record.new(updated_issue)
@@ -112,13 +113,17 @@ class Database
     @log.debug("attempting to delete: #{key}")
     issue = find_issue_by_key(key, options)
 
-    deleted_issue = Retryable.with_context(:default) do
-      wait_for_rate_limit!
-      @client.close_issue(@repo.full_name, issue.number)
-    end
+    deleted_issue = @client.close_issue(@repo.full_name, issue.number)
 
-    # remove the issue from the cache
-    @issues.delete(issue)
+    # update the issue in the cache using the reference we have
+    index = @issues.index(issue)
+    if index
+      @issues[index] = deleted_issue
+    else
+      @log.warn("issue not found in cache during delete: #{key}")
+      # Force a cache refresh to ensure consistency
+      update_issue_cache!
+    end
 
     # return the deleted issue as a Record object as it may contain useful data
     return Record.new(deleted_issue)
@@ -132,7 +137,10 @@ class Database
   # options = {include_closed: true}
   # keys = db.list_keys(options)
   def list_keys(options = {})
-    keys = issues.select do |issue|
+    current_issues = issues
+    return [] if current_issues.nil?
+
+    keys = current_issues.select do |issue|
       options[:include_closed] || issue[:state] == "open"
     end.map do |issue|
       issue[:title]
@@ -149,7 +157,10 @@ class Database
   # options = {include_closed: true}
   # records = db.list(options)
   def list(options = {})
-    records = issues.select do |issue|
+    current_issues = issues
+    return [] if current_issues.nil?
+
+    records = current_issues.select do |issue|
       options[:include_closed] || issue[:state] == "open"
     end.map do |issue|
       Record.new(issue)
@@ -199,9 +210,8 @@ class Database
     # update the issues cache if it is nil
     update_issue_cache! if @issues.nil?
 
-    # update the cache if it has expired
-    issues_cache_expired = (Time.now - @issues_last_updated) > @cache_expiry
-    if issues_cache_expired
+    # update the cache if it has expired (with nil safety)
+    if !@issues_last_updated.nil? && (Time.now - @issues_last_updated) > @cache_expiry
       @log.debug("issue cache expired - last updated: #{@issues_last_updated} - refreshing now")
       update_issue_cache!
     end

data/lib/issue_db/utils/github.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+# This class provides a comprehensive wrapper around the Octokit client for GitHub App authentication.
+# It handles token generation and refreshing, built-in retry logic, rate limiting, and delegates method calls to the Octokit client.
+# Helpful: https://github.com/octokit/handbook?tab=readme-ov-file#github-app-authentication-json-web-token
+
+# Why? In some cases, you may not want to have a static long lived token like a GitHub PAT when authenticating...
+# with octokit.rb.
+# Most importantly, this class will handle automatic token refreshing, retries, and rate limiting for you out-of-the-box.
+# Simply provide the correct environment variables, call `GitHub.new`, and then use the returned object as you would an Octokit client.
+
+# Note: Environment variables have the `GH_` prefix because in GitHub Actions, you cannot use `GITHUB_` for secrets
+
+require "octokit"
+require "jwt"
+require "redacting_logger"
+
+class GitHub
+  TOKEN_EXPIRATION_TIME = 2700 # 45 minutes
+  JWT_EXPIRATION_TIME = 600 # 10 minutes
+
+  def initialize(log: nil, app_id: nil, installation_id: nil, app_key: nil, app_algo: nil)
+    @log = log || create_default_logger
+
+    # app ids are found on the App's settings page
+    @app_id = app_id || fetch_env_var("GH_APP_ID").to_i
+
+    # installation ids look like this:
+    # https://github.com/organizations/<org>/settings/installations/<8_digit_id>
+    @installation_id = installation_id || fetch_env_var("GH_APP_INSTALLATION_ID").to_i
+
+    # app keys are found on the App's settings page and can be downloaded
+    # format: "-----BEGIN...key\n...END-----\n"
+    # make sure this key in your env is a single line string with newlines as "\n"
+    @app_key = resolve_app_key(app_key)
+
+    @app_algo = app_algo || ENV.fetch("GH_APP_ALGO", "RS256")
+
+    @client = nil
+    @token_refresh_time = nil
+    @rate_limit_all = nil
+
+    setup_retry_config!
+  end
+
+  # A helper method to check the client's current rate limit status before making a request
+  # NOTE: This method will sleep for the remaining time until the rate limit resets if the rate limit is hit
+  # :param: type [Symbol] the type of rate limit to check (core, search, graphql, etc) - default: :core
+  # :return: nil (nothing) - this method will block until the rate limit is reset for the given type
+  def wait_for_rate_limit!(type = :core)
+    @log.debug("checking rate limit status for type: #{type}")
+    # make a request to get the comprehensive rate limit status
+    # note: checking the rate limit status does not count against the rate limit in any way
+    fetch_rate_limit if @rate_limit_all.nil?
+
+    details = rate_limit_details(type)
+    rate_limit = details[:rate_limit]
+    resets_at = details[:resets_at]
+
+    @log.debug(
+      "rate_limit remaining: #{rate_limit[:remaining]} - " \
+      "used: #{rate_limit[:used]} - " \
+      "resets_at: #{resets_at} - " \
+      "current time: #{Time.now}"
+    )
+
+    # exit early if the rate limit is not hit (we have remaining requests)
+    unless rate_limit[:remaining].zero?
+      update_rate_limit(type)
+      return
+    end
+
+    # if we make it here, we (probably) have hit the rate limit
+    # fetch the rate limit again if we are at zero or if the rate limit reset time is in the past
+    fetch_rate_limit if rate_limit[:remaining].zero? || rate_limit[:remaining] < 0 || resets_at < Time.now
+
+    details = rate_limit_details(type)
+    rate_limit = details[:rate_limit]
+    resets_at = details[:resets_at]
+
+    # exit early if the rate limit is not actually hit (we have remaining requests)
+    unless rate_limit[:remaining].zero?
+      @log.debug("rate_limit not hit - remaining: #{rate_limit[:remaining]}")
+      update_rate_limit(type)
+      return
+    end
+
+    # calculate the sleep duration - ex: reset time - current time
+    sleep_duration = resets_at - Time.now
+    @log.debug("sleep_duration: #{sleep_duration}")
+    sleep_duration = [sleep_duration, 0].max # ensure sleep duration is not negative
+    sleep_duration_and_a_little_more = sleep_duration.ceil + 2 # sleep a little more than the rate limit reset time
+
+    # log the sleep duration and begin the blocking sleep call
+    @log.info("github rate_limit hit: sleeping for: #{sleep_duration_and_a_little_more} seconds")
+    sleep(sleep_duration_and_a_little_more)
+
+    @log.info("github rate_limit sleep complete - Time.now: #{Time.now}")
+  end
+
+  private
+
+  # Creates a default logger if none is provided
+  # @return [RedactingLogger] A new logger instance
+  def create_default_logger
+    RedactingLogger.new($stdout, level: ENV.fetch("GH_APP_LOG_LEVEL", "INFO").upcase)
+  end
+
+  # Sets up retry configuration for handling API errors
+  # Should the number of retries be reached without success, the last exception will be raised
+  def setup_retry_config!
+    @retry_sleep = ENV.fetch("GH_APP_SLEEP", 3).to_i
+    @retry_tries = ENV.fetch("GH_APP_RETRIES", 10).to_i
+    @retry_exponential_backoff = ENV.fetch("GH_APP_EXPONENTIAL_BACKOFF", "false").downcase == "true"
+  end
+
+  # Custom retry logic with optional exponential backoff and logging
+  # @param retries [Integer] Number of retries to attempt
+  # @param sleep_time [Integer] Base sleep time between retries
+  # @param block [Proc] The block to execute with retry logic
+  # @return [Object] The result of the block execution
+  # When exponential backoff is enabled (default is disabled):
+  # 1st retry: 3 seconds
+  # 2nd retry: 6 seconds
+  # 3rd retry: 12 seconds
+  # 4th retry: 24 seconds
+  # When exponential backoff is disabled:
+  # All retries: 3 seconds (fixed rate)
+  def retry_request(retries: @retry_tries, sleep_time: @retry_sleep, &block)
+    attempt = 0
+    begin
+      attempt += 1
+      yield
+    rescue StandardError => e
+      if attempt < retries
+        if @retry_exponential_backoff
+          backoff_time = sleep_time * (2**(attempt - 1)) # Exponential backoff
+        else
+          backoff_time = sleep_time # Fixed rate
+        end
+        @log.debug("[retry ##{attempt}] #{e.class}: #{e.message} - sleeping #{backoff_time}s before retry")
+        sleep(backoff_time)
+        retry
+      else
+        @log.debug("[retry ##{attempt}] #{e.class}: #{e.message} - max retries exceeded")
+        raise e
+      end
+    end
+  end
+
+  def fetch_rate_limit
+    @rate_limit_all = retry_request do
+      client.get("rate_limit")
+    end
+  end
+
+  # Update the in-memory "cached" rate limit value for the given rate limit type
+  def update_rate_limit(type)
+    @rate_limit_all[:resources][type][:remaining] -= 1
+  end
+
+  def rate_limit_details(type)
+    # fetch the provided rate limit type
+    # rate_limit resulting structure: {:limit=>5000, :used=>15, :remaining=>4985, :reset=>1713897293}
+    rate_limit = @rate_limit_all[:resources][type]
+
+    # calculate the time the rate limit will reset
+    resets_at = Time.at(rate_limit[:reset]).utc
+
+    return {
+      rate_limit: rate_limit,
+      resets_at: resets_at,
+    }
+  end
+
+  private
+
+  # Fetches the value of an environment variable and raises an error if it is not set.
+  # @param key [String] The name of the environment variable.
+  # @return [String] The value of the environment variable.
+  def fetch_env_var(key)
+    ENV.fetch(key) { raise "environment variable #{key} is not set" }
+  end
+
+  # Resolves the app key from various sources
+  # @param app_key [String, nil] The app key parameter
+  # @return [String] The resolved app key content
+  def resolve_app_key(app_key)
+    # If app_key is provided as a parameter
+    if app_key
+      # Check if it's a file path (ends with .pem)
+      if app_key.end_with?(".pem")
+        unless File.exist?(app_key)
+          raise "App key file not found: #{app_key}"
+        end
+
+        @log.debug("Loading app key from file: #{app_key}")
+        key_content = File.read(app_key)
+
+        if key_content.strip.empty?
+          raise "App key file is empty: #{app_key}"
+        end
+
+        @log.debug("Successfully loaded app key from file (#{key_content.length} characters)")
+        return key_content
+      else
+        # It's a key string, process escape sequences
+        @log.debug("Using provided app key string")
+        return normalize_key_string(app_key)
+      end
+    end
+
+    # Fall back to environment variable
+    @log.debug("Loading app key from environment variable")
+    env_key = fetch_env_var("GH_APP_KEY")
+    normalize_key_string(env_key)
+  end
+
+  # Normalizes escape sequences in key strings safely
+  # @param key_string [String] The key string to normalize
+  # @return [String] The normalized key string
+  def normalize_key_string(key_string)
+    # Use simple string replacement to avoid ReDoS vulnerability
+    # This handles both single \n and multiple consecutive \\n sequences
+    key_string.gsub('\\n', "\n")
+  end
+
+  # Caches the octokit client if it is not nil and the token has not expired
+  # If it is nil or the token has expired, it creates a new client
+  # @return [Octokit::Client] The octokit client
+  def client
+    if @client.nil? || token_expired?
+      @client = create_client
+    end
+
+    @client
+  end
+
+  # A helper method for generating a JWT token for the GitHub App
+  # @return [String] The JWT token
+  def jwt_token
+    private_key = OpenSSL::PKey::RSA.new(@app_key)
+
+    payload = {}.tap do |opts|
+      opts[:iat] = Time.now.to_i - 60 # issued at time, 60 seconds in the past to allow for clock drift
+      opts[:exp] = opts[:iat] + JWT_EXPIRATION_TIME # JWT expiration time (10 minute maximum)
+      opts[:iss] = @app_id # GitHub App ID
+    end
+
+    JWT.encode(payload, private_key, @app_algo)
+  end
+
+  # Creates a new octokit client and fetches a new installation access token
+  # @return [Octokit::Client] The octokit client
+  def create_client
+    client = ::Octokit::Client.new(bearer_token: jwt_token)
+    access_token = client.create_app_installation_access_token(@installation_id)[:token]
+    client = ::Octokit::Client.new(access_token:)
+    client.auto_paginate = true
+    client.per_page = 100
+    @token_refresh_time = Time.now
+    client
+  end
+
+  # GitHub App installation access tokens expire after 1h
+  # This method checks if the token has expired and returns true if it has
+  # It is very cautious and expires tokens at 45 minutes to account for clock drift
+  # @return [Boolean] True if the token has expired, false otherwise
+  def token_expired?
+    @token_refresh_time.nil? || (Time.now - @token_refresh_time) > TOKEN_EXPIRATION_TIME
+  end
+
+  # This method is called when a method is called on the GitHub class that does not exist.
+  # It delegates the method call to the Octokit client with built-in retry logic and rate limiting.
+  # @param method [Symbol] The name of the method being called.
+  # @param args [Array] The arguments passed to the method.
+  # @param block [Proc] An optional block passed to the method.
+  # @return [Object] The result of the method call on the Octokit client.
+  def method_missing(method, *args, **kwargs, &block)
+    # Check if retry is explicitly disabled for this call
+    disable_retry = kwargs.delete(:disable_retry) || false
+
+    # Determine the rate limit type based on the method name and arguments
+    rate_limit_type = case method.to_s
+                      when /search_/
+                        :search
+                      when /graphql/
+                        # :nocov:
+                        :graphql # I don't actually know of any endpoints that match this method sig yet
+                        # :nocov:
+                      else
+                        # Check if this is a GraphQL call via POST
+                        if method.to_s == "post" && args.first&.include?("/graphql")
+                          :graphql
+                        else
+                          :core
+                        end
+                      end
+
+    # Handle special case for search_issues which can hit secondary rate limits
+    if method.to_s == "search_issues"
+      request_proc = proc do
+        wait_for_rate_limit!(rate_limit_type)
+        client.send(method, *args, **kwargs, &block) # rubocop:disable GitHub/AvoidObjectSendWithDynamicMethod
+      end
+
+      begin
+        if disable_retry
+          request_proc.call
+        else
+          retry_request(&request_proc)
+        end
+      rescue StandardError => e
+        # re-raise the error but if its a secondary rate limit error, just sleep for a minute
+        if e.message.include?("exceeded a secondary rate limit")
+          @log.warn("GitHub secondary rate limit hit, sleeping for 60 seconds")
+          sleep(60)
+        end
+        raise e
+      end
+    else
+      # For all other methods, use standard retry and rate limiting
+      request_proc = proc do
+        wait_for_rate_limit!(rate_limit_type)
+        client.send(method, *args, **kwargs, &block) # rubocop:disable GitHub/AvoidObjectSendWithDynamicMethod
+      end
+
+      if disable_retry
+        request_proc.call
+      else
+        retry_request(&request_proc)
+      end
+    end
+  end
+
+  # This method is called to check if the GitHub class responds to a method.
+  # It checks if the Octokit client responds to the method.
+  # @param method [Symbol] The name of the method being checked.
+  # @param include_private [Boolean] Whether to include private methods in the check.
+  # @return [Boolean] True if the Octokit client responds to the method, false otherwise.
+  def respond_to_missing?(method, include_private = false)
+    client.respond_to?(method, include_private) || super
+  end
+end

data/lib/issue_db/utils/init.rb

@@ -9,10 +9,11 @@ module Init
         @repo.full_name,
         @label,
         "000000",
-        { description: "This issue is managed by the issue-db Ruby library. Please do not remove this label." }
+        { description: "This issue is managed by the issue-db Ruby library. Please do not remove this label." },
+        disable_retry: true
       )
     rescue StandardError => e
-      if e.message.include?("code: already_exists")
+      if e.message.include?("already_exists")
         @log.debug("label #{@label} already exists")
       else
         @log.error("error creating label: #{e.message}") unless ENV.fetch("ENV", nil) == "acceptance"

data/lib/issue_db.rb

@@ -3,7 +3,6 @@
 require "redacting_logger"
 
 require_relative "version"
-require_relative "issue_db/utils/retry"
 require_relative "issue_db/utils/init"
 require_relative "issue_db/authentication"
 require_relative "issue_db/models/repository"
@@ -27,7 +26,6 @@ class IssueDB
   # :return: A new IssueDB object
   def initialize(repo, log: nil, octokit_client: nil, label: nil, cache_expiry: nil, init: true)
     @log = log || RedactingLogger.new($stdout, level: ENV.fetch("LOG_LEVEL", "INFO").upcase)
-    Retry.setup!(log: @log)
     @version = VERSION
     @client = Authentication.login(octokit_client, @log)
     @repo = Repository.new(repo)

data/lib/version.rb

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

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: issue-db
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.1.0
 platform: ruby
 authors:
 - runwaylab
 - GrantBirki
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redacting-logger
@@ -26,39 +25,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: retryable
+  name: octokit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.5
+        version: '9.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '11.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
     - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.0.5
-- !ruby/object:Gem::Dependency
-  name: octokit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
       - !ruby/object:Gem::Version
         version: '9.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '9.2'
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: faraday-retry
   requirement: !ruby/object:Gem::Requirement
@@ -83,26 +68,25 @@ dependencies:
   name: jwt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.9'
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.9.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.9'
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.9.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: 'A Ruby Gem to use GitHub Issues as a NoSQL JSON document db
 
   '
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -117,11 +101,9 @@ files:
 - lib/issue_db/models/record.rb
 - lib/issue_db/models/repository.rb
 - lib/issue_db/utils/generate.rb
-- lib/issue_db/utils/github_app.rb
+- lib/issue_db/utils/github.rb
 - lib/issue_db/utils/init.rb
 - lib/issue_db/utils/parse.rb
-- lib/issue_db/utils/retry.rb
-- lib/issue_db/utils/throttle.rb
 - lib/version.rb
 homepage: https://github.com/runwaylab/issue-db
 licenses:
@@ -130,7 +112,6 @@ metadata:
   source_code_uri: https://github.com/runwaylab/issue-db
   documentation_uri: https://github.com/runwaylab/issue-db
   bug_tracker_uri: https://github.com/runwaylab/issue-db/issues
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -145,8 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A Ruby Gem to use GitHub Issues as a NoSQL JSON document db
 test_files: []

data/lib/issue_db/utils/github_app.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-# This class provides a wrapper around the Octokit client for GitHub App authentication.
-# It handles token generation and refreshing, and delegates method calls to the Octokit client.
-# Helpful: https://github.com/octokit/handbook?tab=readme-ov-file#github-app-authentication-json-web-token
-
-# Why? In some cases, you may not want to have a static long lived token like a GitHub PAT when authenticating...
-# with octokit.rb.
-# Most importantly, this class will handle automatic token refreshing for you out-of-the-box. Simply provide the...
-# correct environment variables, call `GitHubApp.new`, and then use the returned object as you would an Octokit client.
-
-require "octokit"
-require "jwt"
-
-class GitHubApp
-  TOKEN_EXPIRATION_TIME = 2700 # 45 minutes
-  JWT_EXPIRATION_TIME = 600 # 10 minutes
-
-  def initialize
-    # app ids are found on the App's settings page
-    @app_id = fetch_env_var("ISSUE_DB_GITHUB_APP_ID").to_i
-
-    # installation ids look like this:
-    # https://github.com/organizations/<org>/settings/installations/<8_digit_id>
-    @installation_id = fetch_env_var("ISSUE_DB_GITHUB_APP_INSTALLATION_ID").to_i
-
-    # app keys are found on the App's settings page and can be downloaded
-    # format: "-----BEGIN...key\n...END-----\n"
-    # make sure this key in your env is a single line string with newlines as "\n"
-    @app_key = fetch_env_var("ISSUE_DB_GITHUB_APP_KEY").gsub(/\\+n/, "\n")
-
-    @client = nil
-    @token_refresh_time = nil
-  end
-
-  private
-
-  # Fetches the value of an environment variable and raises an error if it is not set.
-  # @param key [String] The name of the environment variable.
-  # @return [String] The value of the environment variable.
-  def fetch_env_var(key)
-    ENV.fetch(key) { raise "environment variable #{key} is not set" }
-  end
-
-  # Caches the octokit client if it is not nil and the token has not expired
-  # If it is nil or the token has expired, it creates a new client
-  # @return [Octokit::Client] The octokit client
-  def client
-    if @client.nil? || token_expired?
-      @client = create_client
-    end
-
-    @client
-  end
-
-  # A helper method for generating a JWT token for the GitHub App
-  # @return [String] The JWT token
-  def jwt_token
-    private_key = OpenSSL::PKey::RSA.new(@app_key)
-
-    payload = {}.tap do |opts|
-      opts[:iat] = Time.now.to_i - 60 # issued at time, 60 seconds in the past to allow for clock drift
-      opts[:exp] = opts[:iat] + JWT_EXPIRATION_TIME # JWT expiration time (10 minute maximum)
-      opts[:iss] = @app_id # GitHub App ID
-    end
-
-    JWT.encode(payload, private_key, "RS256")
-  end
-
-  # Creates a new octokit client and fetches a new installation access token
-  # @return [Octokit::Client] The octokit client
-  def create_client
-    client = ::Octokit::Client.new(bearer_token: jwt_token)
-    access_token = client.create_app_installation_access_token(@installation_id)[:token]
-    client = ::Octokit::Client.new(access_token:)
-    client.auto_paginate = true
-    client.per_page = 100
-    @token_refresh_time = Time.now
-    client
-  end
-
-  # GitHub App installation access tokens expire after 1h
-  # This method checks if the token has expired and returns true if it has
-  # It is very cautious and expires tokens at 45 minutes to account for clock drift
-  # @return [Boolean] True if the token has expired, false otherwise
-  def token_expired?
-    @token_refresh_time.nil? || (Time.now - @token_refresh_time) > TOKEN_EXPIRATION_TIME
-  end
-
-  # This method is called when a method is called on the GitHub class that does not exist.
-  # It delegates the method call to the Octokit client.
-  # @param method [Symbol] The name of the method being called.
-  # @param args [Array] The arguments passed to the method.
-  # @param block [Proc] An optional block passed to the method.
-  # @return [Object] The result of the method call on the Octokit client.
-  def method_missing(method, *args, &block)
-    client.send(method, *args, &block) # rubocop:disable GitHub/AvoidObjectSendWithDynamicMethod
-  end
-
-  # This method is called to check if the GitHub class responds to a method.
-  # It checks if the Octokit client responds to the method.
-  # @param method [Symbol] The name of the method being checked.
-  # @param include_private [Boolean] Whether to include private methods in the check.
-  # @return [Boolean] True if the Octokit client responds to the method, false otherwise.
-  def respond_to_missing?(method, include_private = false)
-    client.respond_to?(method, include_private) || super
-  end
-end

data/lib/issue_db/utils/retry.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "retryable"
-
-module Retry
-  # This method should be called as early as possible in the startup of your application
-  # It sets up the Retryable gem with custom contexts and passes through a few options
-  # Should the number of retries be reached without success, the last exception will be raised
-  # :param log: the logger to use for retryable logging
-  def self.setup!(log: nil)
-    raise ArgumentError, "a logger must be provided" if log.nil?
-
-    log_method = lambda do |retries, exception|
-      # :nocov:
-      log.debug("[retry ##{retries}] #{exception.class}: #{exception.message} - #{exception.backtrace.join("\n")}")
-      # :nocov:
-    end
-
-    ######## Retryable Configuration ########
-    # All defaults available here:
-    # https://github.com/nfedyashev/retryable/blob/6a04027e61607de559e15e48f281f3ccaa9750e8/lib/retryable/configuration.rb#L22-L33
-    Retryable.configure do |config|
-      config.contexts[:default] = {
-        on: [StandardError],
-        sleep: ENV.fetch("ISSUE_DB_SLEEP", 3),
-        tries: ENV.fetch("ISSUE_DB_RETRIES", 10),
-        log_method:
-      }
-    end
-  end
-end

data/lib/issue_db/utils/throttle.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Throttle
-  def fetch_rate_limit
-    @rate_limit_all = Retryable.with_context(:default) do
-      @client.get("rate_limit")
-    end
-  end
-
-  # Update the in-memory "cached" rate limit value for the given rate limit type
-  def update_rate_limit(type)
-    @rate_limit_all[:resources][type][:remaining] -= 1
-  end
-
-  def rate_limit_details(type)
-    # fetch the provided rate limit type
-    # rate_limit resulting structure: {:limit=>5000, :used=>15, :remaining=>4985, :reset=>1713897293}
-    rate_limit = @rate_limit_all[:resources][type]
-
-    # calculate the time the rate limit will reset
-    resets_at = Time.at(rate_limit[:reset]).utc
-
-    return {
-      rate_limit: rate_limit,
-      resets_at: resets_at,
-    }
-  end
-
-  # A helper method to check the client's current rate limit status before making a request
-  # NOTE: This method will sleep for the remaining time until the rate limit resets if the rate limit is hit
-  # :param: type [Symbol] the type of rate limit to check (core, search, graphql, etc) - default: :core
-  # :return: nil (nothing) - this method will block until the rate limit is reset for the given type
-  def wait_for_rate_limit!(type = :core)
-    @log.debug("checking rate limit status for type: #{type}")
-    # make a request to get the comprehensive rate limit status
-    # note: checking the rate limit status does not count against the rate limit in any way
-    fetch_rate_limit if @rate_limit_all.nil?
-
-    details = rate_limit_details(type)
-    rate_limit = details[:rate_limit]
-    resets_at = details[:resets_at]
-
-    @log.debug(
-      "rate_limit remaining: #{rate_limit.remaining} - " \
-      "used: #{rate_limit.used} - " \
-      "resets_at: #{resets_at} - " \
-      "current time: #{Time.now}"
-    )
-
-    # exit early if the rate limit is not hit (we have remaining requests)
-    unless rate_limit.remaining.zero?
-      update_rate_limit(type)
-      return
-    end
-
-    # if we make it here, we (probably) have hit the rate limit
-    # fetch the rate limit again if we are at zero or if the rate limit reset time is in the past
-    fetch_rate_limit if rate_limit.remaining.zero? || rate_limit.remaining < 0 || resets_at < Time.now
-
-    details = rate_limit_details(type)
-    rate_limit = details[:rate_limit]
-    resets_at = details[:resets_at]
-
-    # exit early if the rate limit is not actually hit (we have remaining requests)
-    unless rate_limit.remaining.zero?
-      @log.debug("rate_limit not hit - remaining: #{rate_limit.remaining}")
-      update_rate_limit(type)
-      return
-    end
-
-    # calculate the sleep duration - ex: reset time - current time
-    sleep_duration = resets_at - Time.now
-    @log.debug("sleep_duration: #{sleep_duration}")
-    sleep_duration = [sleep_duration, 0].max # ensure sleep duration is not negative
-    sleep_duration_and_a_little_more = sleep_duration.ceil + 2 # sleep a little more than the rate limit reset time
-
-    # log the sleep duration and begin the blocking sleep call
-    @log.info("github rate_limit hit: sleeping for: #{sleep_duration_and_a_little_more} seconds")
-    sleep(sleep_duration_and_a_little_more)
-
-    @log.info("github rate_limit sleep complete - Time.now: #{Time.now}")
-  end
-end