lapsoss 0.1.0 → 0.2.0

data/lib/lapsoss/release_tracker.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "digest"
+require 'digest'
 
 module Lapsoss
   # Release and version tracking system
@@ -16,7 +16,7 @@ module Lapsoss
     end
 
     def get_release_info
-      now = Time.now
+      now = Time.zone.now
 
       # Return cached info if still valid
       if @cached_release_info && @cache_timestamp && (now - @cache_timestamp) < @cache_duration
@@ -28,34 +28,26 @@ module Lapsoss
 
       # Add custom version providers
       @version_providers.each do |provider|
-        begin
-          if provider_info = provider.call
-            release_info.merge!(provider_info)
-          end
-        rescue StandardError => e
-          warn "Release provider failed: #{e.message}"
+        if provider_info = provider.call
+          release_info.merge!(provider_info)
         end
+      rescue StandardError => e
+        warn "Release provider failed: #{e.message}"
       end
 
       # Add Git information
-      if @git_enabled
-        if git_info = detect_git_info
-          release_info.merge!(git_info)
-        end
+      if @git_enabled && (git_info = detect_git_info)
+        release_info.merge!(git_info)
       end
 
       # Add environment information
-      if @environment_enabled
-        if env_info = detect_environment_info
-          release_info.merge!(env_info)
-        end
+      if @environment_enabled && (env_info = detect_environment_info)
+        release_info.merge!(env_info)
       end
 
       # Add deployment information
-      if @deployment_enabled
-        if deployment_info = detect_deployment_info
-          release_info.merge!(deployment_info)
-        end
+      if @deployment_enabled && (deployment_info = detect_deployment_info)
+        release_info.merge!(deployment_info)
       end
 
       # Generate release ID if not provided
@@ -80,44 +72,42 @@ module Lapsoss
     private
 
     def detect_git_info
-      return nil unless File.exist?(".git")
+      return nil unless File.exist?('.git')
 
       git_info = {}
 
       begin
         # Get current commit SHA
-        commit_sha = execute_git_command("rev-parse HEAD")
+        commit_sha = execute_git_command('rev-parse HEAD')
         git_info[:commit_sha] = commit_sha if commit_sha
 
         # Get short commit SHA
-        short_sha = execute_git_command("rev-parse --short HEAD")
+        short_sha = execute_git_command('rev-parse --short HEAD')
         git_info[:short_sha] = short_sha if short_sha
 
         # Get branch name
-        branch = execute_git_command("rev-parse --abbrev-ref HEAD")
-        git_info[:branch] = branch if branch && branch != "HEAD"
+        branch = execute_git_command('rev-parse --abbrev-ref HEAD')
+        git_info[:branch] = branch if branch && branch != 'HEAD'
 
         # Get commit timestamp
-        commit_timestamp = execute_git_command("log -1 --format=%ct")
-        if commit_timestamp && !commit_timestamp.empty?
-          git_info[:commit_timestamp] = Time.at(commit_timestamp.to_i)
-        end
+        commit_timestamp = execute_git_command('log -1 --format=%ct')
+        git_info[:commit_timestamp] = Time.zone.at(commit_timestamp.to_i) if commit_timestamp.present?
 
         # Get commit message
-        commit_message = execute_git_command("log -1 --format=%s")
+        commit_message = execute_git_command('log -1 --format=%s')
         git_info[:commit_message] = commit_message if commit_message
 
         # Get committer info
-        committer = execute_git_command("log -1 --format=%cn")
+        committer = execute_git_command('log -1 --format=%cn')
         git_info[:committer] = committer if committer
 
         # Get tag if on a tag
-        tag = execute_git_command("describe --exact-match --tags HEAD 2>/dev/null")
-        git_info[:tag] = tag if tag && !tag.empty?
+        tag = execute_git_command('describe --exact-match --tags HEAD 2>/dev/null')
+        git_info[:tag] = tag if tag.present?
 
         # Get latest tag
-        latest_tag = execute_git_command("describe --tags --abbrev=0 2>/dev/null")
-        git_info[:latest_tag] = latest_tag if latest_tag && !latest_tag.empty?
+        latest_tag = execute_git_command('describe --tags --abbrev=0 2>/dev/null')
+        git_info[:latest_tag] = latest_tag if latest_tag.present?
 
         # Get commits since latest tag
         if latest_tag
@@ -126,14 +116,12 @@ module Lapsoss
         end
 
         # Check if working directory is dirty
-        git_status = execute_git_command("status --porcelain")
+        git_status = execute_git_command('status --porcelain')
         git_info[:dirty] = !git_status.empty? if git_status
 
         # Get remote URL
-        remote_url = execute_git_command("config --get remote.origin.url")
-        if remote_url
-          git_info[:remote_url] = sanitize_remote_url(remote_url)
-        end
+        remote_url = execute_git_command('config --get remote.origin.url')
+        git_info[:remote_url] = sanitize_remote_url(remote_url) if remote_url
 
         git_info
       rescue StandardError => e
@@ -146,19 +134,19 @@ module Lapsoss
       env_info = {}
 
       # Application version from common environment variables
-      env_info[:app_version] = ENV["APP_VERSION"] if ENV["APP_VERSION"]
-      env_info[:version] = ENV["VERSION"] if ENV["VERSION"]
+      env_info[:app_version] = ENV['APP_VERSION'] if ENV['APP_VERSION']
+      env_info[:version] = ENV['VERSION'] if ENV['VERSION']
 
       # Environment detection
       env_info[:environment] = detect_environment
 
       # Application name
-      env_info[:app_name] = ENV["APP_NAME"] if ENV["APP_NAME"]
+      env_info[:app_name] = ENV['APP_NAME'] if ENV['APP_NAME']
 
       # Build information
-      env_info[:build_number] = ENV["BUILD_NUMBER"] if ENV["BUILD_NUMBER"]
-      env_info[:build_id] = ENV["BUILD_ID"] if ENV["BUILD_ID"]
-      env_info[:build_url] = ENV["BUILD_URL"] if ENV["BUILD_URL"]
+      env_info[:build_number] = ENV['BUILD_NUMBER'] if ENV['BUILD_NUMBER']
+      env_info[:build_id] = ENV['BUILD_ID'] if ENV['BUILD_ID']
+      env_info[:build_url] = ENV['BUILD_URL'] if ENV['BUILD_URL']
 
       # CI/CD information
       env_info[:ci] = detect_ci_info
@@ -170,14 +158,14 @@ module Lapsoss
       deployment_info = {}
 
       # Deployment timestamp
-      if ENV["DEPLOYMENT_TIME"]
-        deployment_info[:deployment_time] = parse_time(ENV["DEPLOYMENT_TIME"])
-      elsif ENV["DEPLOYED_AT"]
-        deployment_info[:deployment_time] = parse_time(ENV["DEPLOYED_AT"])
+      if ENV['DEPLOYMENT_TIME']
+        deployment_info[:deployment_time] = parse_time(ENV['DEPLOYMENT_TIME'])
+      elsif ENV['DEPLOYED_AT']
+        deployment_info[:deployment_time] = parse_time(ENV['DEPLOYED_AT'])
       end
 
       # Deployment ID
-      deployment_info[:deployment_id] = ENV["DEPLOYMENT_ID"] if ENV["DEPLOYMENT_ID"]
+      deployment_info[:deployment_id] = ENV['DEPLOYMENT_ID'] if ENV['DEPLOYMENT_ID']
 
       # Platform-specific detection
       deployment_info.merge!(detect_heroku_info)
@@ -191,113 +179,111 @@ module Lapsoss
     end
 
     def detect_environment
-      return ENV["RAILS_ENV"] if ENV["RAILS_ENV"]
-      return ENV["RACK_ENV"] if ENV["RACK_ENV"]
-      return ENV["NODE_ENV"] if ENV["NODE_ENV"]
-      return ENV["ENVIRONMENT"] if ENV["ENVIRONMENT"]
-      return ENV["ENV"] if ENV["ENV"]
+      return ENV['RAILS_ENV'] if ENV['RAILS_ENV']
+      return ENV['RACK_ENV'] if ENV['RACK_ENV']
+      return ENV['NODE_ENV'] if ENV['NODE_ENV']
+      return ENV['ENVIRONMENT'] if ENV['ENVIRONMENT']
+      return ENV['ENV'] if ENV['ENV']
 
       # Try to detect from Rails if available
-      if defined?(Rails) && Rails.respond_to?(:env)
-        return Rails.env.to_s
-      end
+      return Rails.env.to_s if defined?(Rails) && Rails.respond_to?(:env)
 
       # Default fallback
-      "unknown"
+      'unknown'
     end
 
     def detect_ci_info
       ci_info = {}
 
       # GitHub Actions
-      if ENV["GITHUB_ACTIONS"]
-        ci_info[:provider] = "github_actions"
-        ci_info[:run_id] = ENV["GITHUB_RUN_ID"]
-        ci_info[:run_number] = ENV["GITHUB_RUN_NUMBER"]
-        ci_info[:workflow] = ENV["GITHUB_WORKFLOW"]
-        ci_info[:actor] = ENV["GITHUB_ACTOR"]
-        ci_info[:repository] = ENV["GITHUB_REPOSITORY"]
-        ci_info[:ref] = ENV["GITHUB_REF"]
-        ci_info[:sha] = ENV["GITHUB_SHA"]
+      if ENV['GITHUB_ACTIONS']
+        ci_info[:provider] = 'github_actions'
+        ci_info[:run_id] = ENV.fetch('GITHUB_RUN_ID', nil)
+        ci_info[:run_number] = ENV.fetch('GITHUB_RUN_NUMBER', nil)
+        ci_info[:workflow] = ENV.fetch('GITHUB_WORKFLOW', nil)
+        ci_info[:actor] = ENV.fetch('GITHUB_ACTOR', nil)
+        ci_info[:repository] = ENV.fetch('GITHUB_REPOSITORY', nil)
+        ci_info[:ref] = ENV.fetch('GITHUB_REF', nil)
+        ci_info[:sha] = ENV.fetch('GITHUB_SHA', nil)
       end
 
       # GitLab CI
-      if ENV["GITLAB_CI"]
-        ci_info[:provider] = "gitlab_ci"
-        ci_info[:pipeline_id] = ENV["CI_PIPELINE_ID"]
-        ci_info[:job_id] = ENV["CI_JOB_ID"]
-        ci_info[:job_name] = ENV["CI_JOB_NAME"]
-        ci_info[:commit_sha] = ENV["CI_COMMIT_SHA"]
-        ci_info[:commit_ref] = ENV["CI_COMMIT_REF_NAME"]
-        ci_info[:project_url] = ENV["CI_PROJECT_URL"]
+      if ENV['GITLAB_CI']
+        ci_info[:provider] = 'gitlab_ci'
+        ci_info[:pipeline_id] = ENV.fetch('CI_PIPELINE_ID', nil)
+        ci_info[:job_id] = ENV.fetch('CI_JOB_ID', nil)
+        ci_info[:job_name] = ENV.fetch('CI_JOB_NAME', nil)
+        ci_info[:commit_sha] = ENV.fetch('CI_COMMIT_SHA', nil)
+        ci_info[:commit_ref] = ENV.fetch('CI_COMMIT_REF_NAME', nil)
+        ci_info[:project_url] = ENV.fetch('CI_PROJECT_URL', nil)
       end
 
       # Jenkins
-      if ENV["JENKINS_URL"]
-        ci_info[:provider] = "jenkins"
-        ci_info[:build_number] = ENV["BUILD_NUMBER"]
-        ci_info[:build_id] = ENV["BUILD_ID"]
-        ci_info[:job_name] = ENV["JOB_NAME"]
-        ci_info[:build_url] = ENV["BUILD_URL"]
-        ci_info[:git_commit] = ENV["GIT_COMMIT"]
-        ci_info[:git_branch] = ENV["GIT_BRANCH"]
+      if ENV['JENKINS_URL']
+        ci_info[:provider] = 'jenkins'
+        ci_info[:build_number] = ENV.fetch('BUILD_NUMBER', nil)
+        ci_info[:build_id] = ENV.fetch('BUILD_ID', nil)
+        ci_info[:job_name] = ENV.fetch('JOB_NAME', nil)
+        ci_info[:build_url] = ENV.fetch('BUILD_URL', nil)
+        ci_info[:git_commit] = ENV.fetch('GIT_COMMIT', nil)
+        ci_info[:git_branch] = ENV.fetch('GIT_BRANCH', nil)
       end
 
       # CircleCI
-      if ENV["CIRCLECI"]
-        ci_info[:provider] = "circleci"
-        ci_info[:build_num] = ENV["CIRCLE_BUILD_NUM"]
-        ci_info[:workflow_id] = ENV["CIRCLE_WORKFLOW_ID"]
-        ci_info[:job] = ENV["CIRCLE_JOB"]
-        ci_info[:project_reponame] = ENV["CIRCLE_PROJECT_REPONAME"]
-        ci_info[:sha1] = ENV["CIRCLE_SHA1"]
-        ci_info[:branch] = ENV["CIRCLE_BRANCH"]
+      if ENV['CIRCLECI']
+        ci_info[:provider] = 'circleci'
+        ci_info[:build_num] = ENV.fetch('CIRCLE_BUILD_NUM', nil)
+        ci_info[:workflow_id] = ENV.fetch('CIRCLE_WORKFLOW_ID', nil)
+        ci_info[:job] = ENV.fetch('CIRCLE_JOB', nil)
+        ci_info[:project_reponame] = ENV.fetch('CIRCLE_PROJECT_REPONAME', nil)
+        ci_info[:sha1] = ENV.fetch('CIRCLE_SHA1', nil)
+        ci_info[:branch] = ENV.fetch('CIRCLE_BRANCH', nil)
       end
 
       # Travis CI
-      if ENV["TRAVIS"]
-        ci_info[:provider] = "travis"
-        ci_info[:build_id] = ENV["TRAVIS_BUILD_ID"]
-        ci_info[:build_number] = ENV["TRAVIS_BUILD_NUMBER"]
-        ci_info[:job_id] = ENV["TRAVIS_JOB_ID"]
-        ci_info[:commit] = ENV["TRAVIS_COMMIT"]
-        ci_info[:branch] = ENV["TRAVIS_BRANCH"]
-        ci_info[:tag] = ENV["TRAVIS_TAG"]
+      if ENV['TRAVIS']
+        ci_info[:provider] = 'travis'
+        ci_info[:build_id] = ENV.fetch('TRAVIS_BUILD_ID', nil)
+        ci_info[:build_number] = ENV.fetch('TRAVIS_BUILD_NUMBER', nil)
+        ci_info[:job_id] = ENV.fetch('TRAVIS_JOB_ID', nil)
+        ci_info[:commit] = ENV.fetch('TRAVIS_COMMIT', nil)
+        ci_info[:branch] = ENV.fetch('TRAVIS_BRANCH', nil)
+        ci_info[:tag] = ENV.fetch('TRAVIS_TAG', nil)
       end
 
       ci_info
     end
 
     def detect_heroku_info
-      return {} unless ENV["HEROKU_APP_NAME"]
+      return {} unless ENV['HEROKU_APP_NAME']
 
       {
-        platform: "heroku",
-        app_name: ENV["HEROKU_APP_NAME"],
-        dyno: ENV["DYNO"],
-        slug_commit: ENV["HEROKU_SLUG_COMMIT"],
-        release_version: ENV["HEROKU_RELEASE_VERSION"],
-        slug_description: ENV["HEROKU_SLUG_DESCRIPTION"]
+        platform: 'heroku',
+        app_name: ENV.fetch('HEROKU_APP_NAME', nil),
+        dyno: ENV.fetch('DYNO', nil),
+        slug_commit: ENV.fetch('HEROKU_SLUG_COMMIT', nil),
+        release_version: ENV.fetch('HEROKU_RELEASE_VERSION', nil),
+        slug_description: ENV.fetch('HEROKU_SLUG_DESCRIPTION', nil)
       }
     end
 
     def detect_aws_info
       info = {}
 
-      if ENV["AWS_EXECUTION_ENV"]
-        info[:platform] = "aws"
-        info[:execution_env] = ENV["AWS_EXECUTION_ENV"]
-        info[:region] = ENV["AWS_REGION"] || ENV["AWS_DEFAULT_REGION"]
-        info[:function_name] = ENV["AWS_LAMBDA_FUNCTION_NAME"]
-        info[:function_version] = ENV["AWS_LAMBDA_FUNCTION_VERSION"]
+      if ENV['AWS_EXECUTION_ENV']
+        info[:platform] = 'aws'
+        info[:execution_env] = ENV['AWS_EXECUTION_ENV']
+        info[:region] = ENV['AWS_REGION'] || ENV.fetch('AWS_DEFAULT_REGION', nil)
+        info[:function_name] = ENV.fetch('AWS_LAMBDA_FUNCTION_NAME', nil)
+        info[:function_version] = ENV.fetch('AWS_LAMBDA_FUNCTION_VERSION', nil)
       end
 
       # EC2 metadata (if available)
-      if ENV["EC2_INSTANCE_ID"]
-        info[:platform] = "aws_ec2"
-        info[:instance_id] = ENV["EC2_INSTANCE_ID"]
-        info[:instance_type] = ENV["EC2_INSTANCE_TYPE"]
-        info[:availability_zone] = ENV["EC2_AVAILABILITY_ZONE"]
+      if ENV['EC2_INSTANCE_ID']
+        info[:platform] = 'aws_ec2'
+        info[:instance_id] = ENV['EC2_INSTANCE_ID']
+        info[:instance_type] = ENV.fetch('EC2_INSTANCE_TYPE', nil)
+        info[:availability_zone] = ENV.fetch('EC2_AVAILABILITY_ZONE', nil)
       end
 
       info
@@ -306,21 +292,21 @@ module Lapsoss
     def detect_gcp_info
       info = {}
 
-      if ENV["GOOGLE_CLOUD_PROJECT"]
-        info[:platform] = "gcp"
-        info[:project] = ENV["GOOGLE_CLOUD_PROJECT"]
-        info[:region] = ENV["GOOGLE_CLOUD_REGION"]
-        info[:function_name] = ENV["FUNCTION_NAME"]
-        info[:function_signature_type] = ENV["FUNCTION_SIGNATURE_TYPE"]
+      if ENV['GOOGLE_CLOUD_PROJECT']
+        info[:platform] = 'gcp'
+        info[:project] = ENV['GOOGLE_CLOUD_PROJECT']
+        info[:region] = ENV.fetch('GOOGLE_CLOUD_REGION', nil)
+        info[:function_name] = ENV.fetch('FUNCTION_NAME', nil)
+        info[:function_signature_type] = ENV.fetch('FUNCTION_SIGNATURE_TYPE', nil)
       end
 
       # App Engine
-      if ENV["GAE_APPLICATION"]
-        info[:platform] = "gcp_app_engine"
-        info[:application] = ENV["GAE_APPLICATION"]
-        info[:service] = ENV["GAE_SERVICE"]
-        info[:version] = ENV["GAE_VERSION"]
-        info[:runtime] = ENV["GAE_RUNTIME"]
+      if ENV['GAE_APPLICATION']
+        info[:platform] = 'gcp_app_engine'
+        info[:application] = ENV['GAE_APPLICATION']
+        info[:service] = ENV.fetch('GAE_SERVICE', nil)
+        info[:version] = ENV.fetch('GAE_VERSION', nil)
+        info[:runtime] = ENV.fetch('GAE_RUNTIME', nil)
       end
 
       info
@@ -329,12 +315,12 @@ module Lapsoss
     def detect_azure_info
       info = {}
 
-      if ENV["WEBSITE_SITE_NAME"]
-        info[:platform] = "azure"
-        info[:site_name] = ENV["WEBSITE_SITE_NAME"]
-        info[:resource_group] = ENV["WEBSITE_RESOURCE_GROUP"]
-        info[:subscription_id] = ENV["WEBSITE_OWNER_NAME"]
-        info[:sku] = ENV["WEBSITE_SKU"]
+      if ENV['WEBSITE_SITE_NAME']
+        info[:platform] = 'azure'
+        info[:site_name] = ENV['WEBSITE_SITE_NAME']
+        info[:resource_group] = ENV.fetch('WEBSITE_RESOURCE_GROUP', nil)
+        info[:subscription_id] = ENV.fetch('WEBSITE_OWNER_NAME', nil)
+        info[:sku] = ENV.fetch('WEBSITE_SKU', nil)
       end
 
       info
@@ -343,11 +329,11 @@ module Lapsoss
     def detect_docker_info
       info = {}
 
-      if ENV["DOCKER_CONTAINER_ID"] || File.exist?("/.dockerenv")
-        info[:platform] = "docker"
-        info[:container_id] = ENV["DOCKER_CONTAINER_ID"]
-        info[:image] = ENV["DOCKER_IMAGE"]
-        info[:tag] = ENV["DOCKER_TAG"]
+      if ENV['DOCKER_CONTAINER_ID'] || File.exist?('/.dockerenv')
+        info[:platform] = 'docker'
+        info[:container_id] = ENV['DOCKER_CONTAINER_ID']
+        info[:image] = ENV.fetch('DOCKER_IMAGE', nil)
+        info[:tag] = ENV.fetch('DOCKER_TAG', nil)
       end
 
       info
@@ -356,13 +342,13 @@ module Lapsoss
     def detect_kubernetes_info
       info = {}
 
-      if ENV["KUBERNETES_SERVICE_HOST"]
-        info[:platform] = "kubernetes"
-        info[:namespace] = ENV["KUBERNETES_NAMESPACE"]
-        info[:pod_name] = ENV["HOSTNAME"]
-        info[:service_account] = ENV["KUBERNETES_SERVICE_ACCOUNT"]
-        info[:cluster_name] = ENV["CLUSTER_NAME"]
-        info[:node_name] = ENV["NODE_NAME"]
+      if ENV['KUBERNETES_SERVICE_HOST']
+        info[:platform] = 'kubernetes'
+        info[:namespace] = ENV.fetch('KUBERNETES_NAMESPACE', nil)
+        info[:pod_name] = ENV.fetch('HOSTNAME', nil)
+        info[:service_account] = ENV.fetch('KUBERNETES_SERVICE_ACCOUNT', nil)
+        info[:cluster_name] = ENV.fetch('CLUSTER_NAME', nil)
+        info[:node_name] = ENV.fetch('NODE_NAME', nil)
       end
 
       info
@@ -377,7 +363,7 @@ module Lapsoss
 
     def sanitize_remote_url(url)
       # Remove credentials from Git URLs
-      url.gsub(%r{://[^@/]+@}, "://")
+      url.gsub(%r{://[^@/]+@}, '://')
     end
 
     def parse_time(time_str)
@@ -385,24 +371,22 @@ module Lapsoss
 
       # Try different time formats
       formats = [
-        "%Y-%m-%dT%H:%M:%S%z",      # ISO 8601 with timezone
-        "%Y-%m-%dT%H:%M:%SZ",       # ISO 8601 UTC
-        "%Y-%m-%d %H:%M:%S %z",     # Standard format with timezone
-        "%Y-%m-%d %H:%M:%S",        # Standard format without timezone
-        "%s"                        # Unix timestamp
+        '%Y-%m-%dT%H:%M:%S%z',      # ISO 8601 with timezone
+        '%Y-%m-%dT%H:%M:%SZ',       # ISO 8601 UTC
+        '%Y-%m-%d %H:%M:%S %z',     # Standard format with timezone
+        '%Y-%m-%d %H:%M:%S',        # Standard format without timezone
+        '%s'                        # Unix timestamp
       ]
 
       formats.each do |format|
-        begin
-          return Time.strptime(time_str, format)
-        rescue ArgumentError
-          next
-        end
+        return Time.strptime(time_str, format)
+      rescue ArgumentError
+        next
       end
 
       # Try parsing as integer (Unix timestamp)
       begin
-        return Time.at(time_str.to_i) if time_str.match?(/^\d+$/)
+        return Time.zone.at(time_str.to_i) if time_str.match?(/^\d+$/)
       rescue ArgumentError
         nil
       end
@@ -429,7 +413,7 @@ module Lapsoss
 
       # If we have components, join them
       if components.any?
-        release_id = components.join("-")
+        release_id = components.join('-')
         # Truncate if too long
         release_id.length > 64 ? release_id[0, 64] : release_id
       else
@@ -461,20 +445,18 @@ module Lapsoss
 
     def self.from_ruby_constant(constant_name)
       lambda do
-        begin
-          constant = Object.const_get(constant_name)
-          { version: constant.to_s }
-        rescue NameError
-          nil
-        end
+        constant = Object.const_get(constant_name)
+        { version: constant.to_s }
+      rescue NameError
+        nil
       end
     end
 
     def self.from_gemfile_lock
       lambda do
-        return nil unless File.exist?("Gemfile.lock")
+        return nil unless File.exist?('Gemfile.lock')
 
-        content = File.read("Gemfile.lock")
+        content = File.read('Gemfile.lock')
 
         # Extract gems with versions
         gems = {}
@@ -488,14 +470,14 @@ module Lapsoss
 
     def self.from_package_json
       lambda do
-        return nil unless File.exist?("package.json")
+        return nil unless File.exist?('package.json')
 
         begin
-          package_info = JSON.parse(File.read("package.json"))
+          package_info = JSON.parse(File.read('package.json'))
           {
-            version: package_info["version"],
-            name: package_info["name"],
-            dependencies: package_info["dependencies"]&.keys
+            version: package_info['version'],
+            name: package_info['name'],
+            dependencies: package_info['dependencies']&.keys
           }.compact
         rescue JSON::ParserError
           nil
@@ -517,14 +499,10 @@ module Lapsoss
         }
 
         # Get application version if defined
-        if app.class.respond_to?(:version)
-          info[:app_version] = app.class.version
-        end
+        info[:app_version] = app.class.version if app.class.respond_to?(:version)
 
         # Get application name
-        if app.class.respond_to?(:name)
-          info[:app_name] = app.class.name
-        end
+        info[:app_name] = app.class.name if app.class.respond_to?(:name)
 
         info
       end
@@ -542,7 +520,7 @@ module Lapsoss
           return {
             revision: revision,
             deployed_at: File.mtime(file),
-            deployment_method: "capistrano"
+            deployment_method: 'capistrano'
           }
         end
 

data/lib/lapsoss/router.rb

@@ -9,11 +9,9 @@ module Lapsoss
       # @param event [Lapsoss::Event] The event to process.
       def process_event(event)
         Registry.instance.active.each do |adapter|
-          begin
-            adapter.capture(event)
-          rescue => e
-            handle_adapter_error(adapter, event, e)
-          end
+          adapter.capture(event)
+        rescue StandardError => e
+          handle_adapter_error(adapter, event, e)
         end
       end