rollbar 2.8.3 → 3.6.0

data/lib/generators/rollbar/rollbar_generator.rb

@@ -1,46 +1,50 @@
 require 'rails/generators'
 require 'rails/generators/named_base'
+require 'generators/rollbar/rollbar_generator'
 
 module Rollbar
   module Generators
     class RollbarGenerator < ::Rails::Generators::Base
-      argument :access_token, :type => :string, :banner => 'access_token', :default => :use_env_sentinel
+      argument :access_token, :type => :string, :banner => 'access_token',
+                              :default => :use_env_sentinel
 
       source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
 
       def create_initializer
-        say "creating initializer..."
+        say 'creating initializer...'
         if access_token_configured?
           say "It looks like you've already configured Rollbar."
-          say "To re-create the config file, remove it first: config/initializers/rollbar.rb"
+          say 'To re-create the config file, remove it first: ' \
+            'config/initializers/rollbar.rb'
           exit
         end
 
         begin
           require 'ey_config'
         rescue LoadError
+          # Skip loading
         end
-        
+
         if defined? EY::Config
-            say "Access token will be read from Engine Yard configuration"
+          say 'Access token will be read from Engine Yard configuration'
+        elsif access_token === :use_env_sentinel
+          say 'Generator run without an access token; assuming you want to ' \
+            'configure using an environment variable.'
+          say "You'll need to add an environment variable ROLLBAR_ACCESS_TOKEN " \
+            'with your access token:'
+          say "\n$ export ROLLBAR_ACCESS_TOKEN=yourtokenhere"
+          say "\nIf that's not what you wanted to do:"
+          say "\n$ rm config/initializers/rollbar.rb"
+          say '$ rails generate rollbar yourtokenhere'
+          say "\n"
         else
-          if access_token === :use_env_sentinel
-            say "Generator run without an access token; assuming you want to configure using an environment variable."
-            say "You'll need to add an environment variable ROLLBAR_ACCESS_TOKEN with your access token:"
-            say "\n$ export ROLLBAR_ACCESS_TOKEN=yourtokenhere"
-            say "\nIf that's not what you wanted to do:"
-            say "\n$ rm config/initializers/rollbar.rb"
-            say "$ rails generate rollbar yourtokenhere"
-            say "\n"
-          else
-            say "access token: " << access_token
-          end
+          say 'access token: ' << access_token
         end
 
-        template 'initializer.rb', 'config/initializers/rollbar.rb',
-          :assigns => { :access_token => access_token_expr }
+        template 'initializer.erb', 'config/initializers/rollbar.rb',
+                 :assigns => { :access_token => access_token_expr }
 
-        # TODO run rake test task
+        # TODO: run rake test task
       end
 
       def access_token_expr
@@ -52,7 +56,7 @@ module Rollbar
       end
 
       def access_token_configured?
-        File.exists?('config/initializers/rollbar.rb')
+        File.exist?('config/initializers/rollbar.rb')
       end
     end
   end

data/lib/generators/rollbar/templates/{initializer.rb → initializer.erb}

@@ -19,12 +19,14 @@ Rollbar.configure do |config|
 <%- end -%>
 
   # By default, Rollbar will try to call the `current_user` controller method
-  # to fetch the logged-in user object, and then call that object's `id`,
-  # `username`, and `email` methods to fetch those properties. To customize:
+  # to fetch the logged-in user object, and then call that object's `id`
+  # method to fetch this property. To customize:
   # config.person_method = "my_current_user"
   # config.person_id_method = "my_id"
-  # config.person_username_method = "my_username"
-  # config.person_email_method = "my_email"
+
+  # Additionally, you may specify the following:
+  # config.person_username_method = "username"
+  # config.person_email_method = "email"
 
   # If you want to attach custom data to all exception and message reports,
   # provide a lambda like the following. It should return a hash.
@@ -57,10 +59,22 @@ Rollbar.configure do |config|
   # You can supply custom Sidekiq options:
   # config.use_sidekiq 'queue' => 'default'
 
+  # If your application runs behind a proxy server, you can set proxy parameters here.
+  # If https_proxy is set in your environment, that will be used. Settings here have precedence.
+  # The :host key is mandatory and must include the URL scheme (e.g. 'http://'), all other fields
+  # are optional.
+  #
+  # config.proxy = {
+  #   host: 'http://some.proxy.server',
+  #   port: 80,
+  #   user: 'username_if_auth_required',
+  #   password: 'password_if_auth_required'
+  # }
+
   # If you run your staging application instance in production environment then
   # you'll want to override the environment reported by `Rails.env` with an
   # environment variable like this: `ROLLBAR_ENV=staging`. This is a recommended
   # setup for Heroku. See:
   # https://devcenter.heroku.com/articles/deploying-to-a-custom-rails-environment
-  config.environment = ENV['ROLLBAR_ENV'] || Rails.env
+  config.environment = ENV['ROLLBAR_ENV'].presence || Rails.env
 end

data/lib/rails/rollbar_runner.rb

@@ -1,23 +1,16 @@
 require 'rails'
 require 'rollbar'
 
-APP_PATH = File.expand_path('config/application', Dir.pwd)
+# Rails.root is not present here.
+# RSpec needs ENV['DUMMYAPP_PATH'] in order to have a valid path.
+# Dir.pwd is used in normal operation.
+APP_PATH = File.expand_path(
+  'config/application',
+  (ENV['DUMMYAPP_PATH'] || Dir.pwd)
+)
 
 module Rails
   class RollbarRunner
-    class GemResolver
-      def railties_gem
-        Gem::Specification.find_by_name('railties')
-      end
-    end
-
-    class LegacyGemResolver
-      def railties_gem
-        searcher = Gem::GemPathSearcher.new
-        searcher.find('rails')
-      end
-    end
-
     attr_reader :command
 
     def initialize
@@ -36,27 +29,40 @@ module Rails
     end
 
     def eval_runner
+      if Gem::Version.new(Rails.version) >= Gem::Version.new('5.1.0')
+        rails5_runner
+      else
+        legacy_runner
+      end
+    end
+
+    def legacy_runner
       string_to_eval = File.read(runner_path)
 
-      ::Rails.module_eval(<<-EOL,__FILE__,__LINE__ + 2)
+      ::Rails.module_eval(<<-FILE, __FILE__, __LINE__ + 1)
           #{string_to_eval}
-      EOL
+      FILE
+    end
+
+    def rails5_runner
+      require 'rails/command'
+
+      Rails::Command.invoke 'runner', ARGV
     end
 
     def rollbar_managed
       yield
-    rescue => e
+    rescue StandardError => e
       Rollbar.scope(:custom => { :command => command }).error(e)
       raise
     end
 
     def runner_path
-      railties_gem_dir + '/lib/rails/commands/runner.rb'
+      "#{railties_gem_dir}/lib/rails/commands/runner.rb"
     end
 
     def railties_gem
-      resolver_class = Gem::Specification.respond_to?(:find_by_name) ? GemResolver : LegacyGemResolver
-      gem = resolver_class.new.railties_gem
+      gem = Gem::Specification.find_by_name('railties')
 
       abort 'railties gem not found' unless gem
 
@@ -68,5 +74,3 @@ module Rails
     end
   end
 end
-
-

data/lib/rollbar/capistrano.rb

@@ -1,43 +1,83 @@
+# This is a tasks file to use with Capistrano 2
+
 require 'capistrano'
+require 'rollbar/deploy'
+require 'net/http'
+require 'rubygems'
+require 'json'
+require 'rollbar/capistrano_tasks'
 
 module Rollbar
-  module Capistrano
-    def self.load_into(configuration)
-      configuration.load do
-        after 'deploy',            'rollbar:deploy'
-        after 'deploy:migrations', 'rollbar:deploy'
-        after 'deploy:cold',       'rollbar:deploy'
-
-        namespace :rollbar do
-          desc 'Send the deployment notification to Rollbar.'
-          task :deploy, :except => { :no_release => true } do
-            require 'net/http'
-            require 'rubygems'
-            require 'json'
-
-            _cset(:rollbar_user)  { ENV['USER'] || ENV['USERNAME'] }
-            _cset(:rollbar_env)   { fetch(:rails_env, 'production') }
-            _cset(:rollbar_token) { abort("Please specify the Rollbar access token, set :rollbar_token, 'your token'") }
-
-            unless configuration.dry_run
-              uri = URI.parse('https://api.rollbar.com/api/1/deploy/')
-
-              params = {
-                :local_username => rollbar_user,
-                :access_token => rollbar_token,
-                :environment => rollbar_env,
-                :revision => current_revision
-              }
-
-              request = Net::HTTP::Post.new(uri.request_uri)
-              request.body = ::JSON.dump(params)
-
-              Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
-                http.request(request)
-              end
-            end
-
-            logger.info('Rollbar notification complete')
+  # Module for loading Rollbar Capistrano tasks into Capistrano 2
+  module Capistrano2
+    class << self
+      def load_into(configuration)
+        load_tasks(configuration)
+        load_tasks_flow(configuration)
+        load_properties(configuration)
+      end
+
+      private
+
+      def load_tasks_flow(configuration)
+        configuration.load do
+          before 'deploy', 'rollbar:deploy_started'
+
+          after 'deploy', 'rollbar:deploy_succeeded'
+          after 'deploy:migrations', 'rollbar:deploy_succeeded'
+          after 'deploy:cold',       'rollbar:deploy_succeeded'
+        end
+      end
+
+      def load_properties(configuration)
+        configuration.load do
+          _cset(:rollbar_role)  { :app }
+          _cset(:rollbar_user)  { ENV['USER'] || ENV['USERNAME'] }
+          _cset(:rollbar_env)   { fetch(:rails_env, 'production') }
+          _cset(:rollbar_token) do
+            abort(
+              "Please specify the Rollbar access token, set :rollbar_token, 'your token'"
+            )
+          end
+          _cset(:rollbar_revision) { real_revision }
+          _cset(:rollbar_comment) { nil }
+        end
+      end
+
+      def load_tasks(configuration)
+        load_deploy_started(configuration)
+        load_deploy_succeeded(configuration)
+      end
+
+      def load_deploy_started(configuration)
+        load_task(
+          :desc => 'Send deployment started notification to Rollbar.',
+          :task => :deploy_started,
+          :configuration => configuration
+        ) do
+          ::Rollbar::CapistranoTasks.deploy_started(
+            configuration, configuration.logger, configuration.dry_run
+          )
+        end
+      end
+
+      def load_deploy_succeeded(configuration)
+        load_task(
+          :desc => 'Send deployment succeeded notification to Rollbar.',
+          :task => :deploy_succeeded,
+          :configuration => configuration
+        ) do
+          ::Rollbar::CapistranoTasks.deploy_succeeded(
+            configuration, configuration.logger, configuration.dry_run
+          )
+        end
+      end
+
+      def load_task(configuration:, desc:, task:, &block)
+        configuration.load do
+          namespace :rollbar do
+            desc(desc)
+            task(task, &block)
           end
         end
       end
@@ -46,5 +86,5 @@ module Rollbar
 end
 
 if Capistrano::Configuration.instance
-  Rollbar::Capistrano.load_into(Capistrano::Configuration.instance)
+  Rollbar::Capistrano2.load_into(Capistrano::Configuration.instance)
 end

data/lib/rollbar/capistrano3.rb

@@ -1 +1,62 @@
-load File.expand_path("../tasks/rollbar.cap", __FILE__)
+# This is a tasks file to use with Capistrano 3
+
+require 'net/http'
+require 'rubygems'
+require 'json'
+require 'rollbar/deploy'
+require 'rollbar/capistrano_tasks'
+
+namespace :rollbar do
+  # dry_run? wasn't introduced till Capistrano 3.5.0; use the old fetch(:sshkit_backed)
+  set :dry_run, (proc {
+                   ::Capistrano::Configuration.env.fetch(:sshkit_backend) ==
+                     ::SSHKit::Backend::Printer
+                 })
+
+  desc 'Send deployment started notification to Rollbar.'
+  task :deploy_started do
+    on primary fetch(:rollbar_role) do
+      ::Rollbar::CapistranoTasks.deploy_started(self, self, fetch(:dry_run))
+    end
+  end
+
+  desc 'Send deployment succeeded notification to Rollbar.'
+  task :deploy_succeeded do
+    on primary fetch(:rollbar_role) do
+      ::Rollbar::CapistranoTasks.deploy_succeeded(self, self, fetch(:dry_run))
+    end
+  end
+
+  desc 'Send deployment failed notification to Rollbar.'
+  task :deploy_failed do
+    on primary fetch(:rollbar_role) do
+      ::Rollbar::CapistranoTasks.deploy_failed(self, self, fetch(:dry_run))
+    end
+  end
+
+  task :fail do
+    raise StandardError
+  end
+end
+
+namespace :deploy do
+  after 'deploy:set_current_revision', 'rollbar:deploy_started'
+  after 'deploy:finished', 'rollbar:deploy_succeeded'
+  after 'deploy:failed', 'rollbar:deploy_failed'
+
+  # Used for testing :deploy_failed task
+  # after 'rollbar:deploy_started', 'rollbar:fail'
+end
+
+namespace :load do
+  task :defaults do
+    set :rollbar_user,      (proc { fetch :local_user, ENV['USER'] || ENV['USERNAME'] })
+    set :rollbar_env,       (proc { fetch :rails_env, 'production' })
+    set :rollbar_token,     (proc {
+                               abort 'Please specify the Rollbar access token, ' \
+                                     "set :rollbar_token, 'your token'"
+                             })
+    set :rollbar_role,      (proc { :app })
+    set :rollbar_revision,  (proc { fetch :current_revision })
+  end
+end

data/lib/rollbar/capistrano_tasks.rb

@@ -0,0 +1,166 @@
+require 'rollbar/deploy'
+
+module Rollbar
+  # Module containing the logic of Capistrano tasks for deploy tracking
+  module CapistranoTasks
+    class << self
+      def deploy_started(capistrano, logger, dry_run)
+        deploy_task(logger, :desc => 'Notifying Rollbar of deployment start') do
+          result = report_deploy_started(capistrano, dry_run)
+
+          debug_request_response(logger, result)
+
+          capistrano.set(:rollbar_deploy_id, 123) if dry_run
+
+          skip_in_dry_run(logger, dry_run) do
+            if result[:success] &&
+               (deploy_id = result[:data] &&
+               result[:data][:deploy_id])
+              capistrano.set :rollbar_deploy_id, deploy_id
+            else
+              message = format_message('Unable to report deploy to Rollbar',
+                                       result[:message])
+              log_error(logger, message)
+            end
+          end
+        end
+      end
+
+      def deploy_succeeded(capistrano, logger, dry_run)
+        deploy_update(
+          capistrano, logger, dry_run,
+          :desc => 'Setting deployment status to `succeeded` in Rollbar'
+        ) do
+          report_deploy_succeeded(capistrano, dry_run)
+        end
+      end
+
+      def deploy_failed(capistrano, logger, dry_run)
+        deploy_update(capistrano, logger, dry_run,
+                      :desc => 'Setting deployment status to `failed` in Rollbar') do
+          report_deploy_failed(capistrano, dry_run)
+        end
+      end
+
+      private
+
+      def deploy_task(logger, opts = {})
+        capistrano_300_warning(logger)
+        logger.info opts[:desc] if opts[:desc]
+        yield
+      rescue StandardError => e
+        log_error logger, "Error reporting to Rollbar: #{e.inspect}"
+      end
+
+      def deploy_update(capistrano, logger, dry_run, opts = {})
+        deploy_task(logger, opts) do
+          depend_on_deploy_id(capistrano, logger) do
+            result = yield
+
+            debug_request_response(logger, result)
+
+            skip_in_dry_run(logger, dry_run) do
+              if result[:success]
+                logger.info 'Updated deploy status in Rollbar'
+              else
+                message = format_message('Unable to update deploy status in Rollbar',
+                                         result[:message])
+                log_error(logger, message)
+              end
+            end
+          end
+        end
+      end
+
+      def capistrano_300_warning(logger)
+        unless ::Capistrano.const_defined?('VERSION') && ::Capistrano::VERSION =~ /^3\.0/
+          return
+        end
+
+        logger.warn('You need to upgrade capistrano to >= 3.1 version in order'\
+          'to correctly report deploys to Rollbar. (On 3.0, the reported revision'\
+          'will be incorrect.)')
+      end
+
+      def report_deploy_started(capistrano, dry_run)
+        ::Rollbar::Deploy.report(
+          {
+            :rollbar_username => capistrano.fetch(:rollbar_user),
+            :local_username => capistrano.fetch(:rollbar_user),
+            :comment => capistrano.fetch(:rollbar_comment),
+            :status => :started,
+            :proxy => :ENV,
+            :dry_run => dry_run
+          },
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_env),
+          capistrano.fetch(:rollbar_revision)
+        )
+      end
+
+      def report_deploy_succeeded(capistrano, dry_run)
+        ::Rollbar::Deploy.update(
+          {
+            :comment => capistrano.fetch(:rollbar_comment),
+            :proxy => :ENV,
+            :dry_run => dry_run
+          },
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_deploy_id),
+          :succeeded
+        )
+      end
+
+      def report_deploy_failed(capistrano, dry_run)
+        ::Rollbar::Deploy.update(
+          {
+            :comment => capistrano.fetch(:rollbar_comment),
+            :proxy => :ENV,
+            :dry_run => dry_run
+          },
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_deploy_id),
+          :failed
+        )
+      end
+
+      def depend_on_deploy_id(capistrano, logger)
+        if capistrano.fetch(:rollbar_deploy_id)
+          yield
+        else
+          log_error logger,
+                    'Failed to update the deploy in Rollbar. No deploy id available.'
+        end
+      end
+
+      def skip_in_dry_run(logger, dry_run)
+        if dry_run
+          logger.info 'Skipping sending HTTP requests to Rollbar in dry run.'
+        else
+          yield
+        end
+      end
+
+      def debug_request_response(logger, result)
+        # NOTE: in Capistrano debug messages go to log/capistrano.log but not to
+        # stdout even if log_level == :debug
+        logger.debug result[:request_info]
+        logger.debug result[:response_info] if result[:response_info]
+      end
+
+      def format_message(*args)
+        args.compact.join(': ')
+      end
+
+      def log_error(logger, message)
+        # Capistrano 2.x doesn't have the #error method,
+        # so we use #important if #error isn't present
+        if logger.respond_to?(:error)
+          logger.error message
+        elsif logger.respond_to?(:important)
+          logger.important message
+        end
+      end
+    end
+  end
+end