roo_on_rails 1.10.0 → 1.11.0

data/lib/roo_on_rails/checks/papertrail/drain_exists.rb

@@ -22,20 +22,20 @@ module RooOnRails
         requires LogDestinationExists
 
         def intro
-          "Checking for Papertrail drain on #{bold app_name}..."
+          'Checking for Papertrail drain...'
         end
 
         def call
           # find the PT drain
           data = client.log_drain.list(app_name).
                  select { |h| h['url'] =~ /papertrailapp/ }
-          fail! 'no Papertrail drain found' if data.empty?
-          fail! 'multiple Papertrail drains found' if data.length > 1
+          fail! "no Papertrail drain found on #{bold app_name}" if data.empty?
+          fail! "multiple Papertrail drains found on #{bold app_name}" if data.length > 1
 
           data = data.first
           fail! "app is draining to #{data['url']} instead of #{papertrail_url}" if data['url'] != papertrail_url
 
-          pass "found drain setup with token #{data['token']}"
+          pass "found drain setup with token #{data['token']} on #{bold app_name}"
           context.papertrail.system_name![env] = data['token']
         end
 

data/lib/roo_on_rails/checks/papertrail/system_exists.rb

@@ -26,14 +26,14 @@ module RooOnRails
         requires LogDestinationExists
 
         def intro
-          "Checking that #{bold app_name} is logging to Papertrail"
+          'Checking that the app is logging to Papertrail...'
         end
 
         def call
           data = context.papertrail.client.list_systems.find { |h|
             h['hostname'] == system_token
           }
-          fail! "no system with token '#{system_token}' found" if data.nil?
+          fail! "no system with token '#{system_token}' found on #{bold app_name}" if data.nil?
 
           if data.syslog.hostname != context.papertrail.dest.host ||
              data.syslog.port != context.papertrail.dest.port

data/lib/roo_on_rails/checks/papertrail/system_named.rb

@@ -21,7 +21,7 @@ module RooOnRails
         requires SystemExists
 
         def intro
-          "Checking that #{bold app_name} is named in Papertrail"
+          'Checking that the app is named in Papertrail'
         end
 
         def call

data/lib/roo_on_rails/checks/sidekiq/settings.rb

@@ -15,7 +15,7 @@ module RooOnRails
           if File.exist?('config/sidekiq.yml')
             message = [
               'Custom Sidekiq settings found.',
-              '  Please see the Roo On Rails readme for more information.'
+              'Please see the Roo On Rails readme for more information.'
             ].join("\n")
 
             fail! message

data/lib/roo_on_rails/checks/sidekiq/sidekiq.rb

@@ -16,6 +16,7 @@ module RooOnRails
             return
           end
           check_for_procfile
+          pass 'found valid Procfile'
         end
 
         def fix

data/lib/roo_on_rails/context_logging.rb

@@ -75,6 +75,7 @@ module RooOnRails
     end
 
     def self.new(logger)
+      warn 'RooOnRails::ContextLogging is deprecated. Please use Rails.logger.'
       # Ensure we set a default formatter so we aren't extending nil!
       logger.formatter ||=
         if ActiveSupport::VERSION::MAJOR >= 4

data/lib/roo_on_rails/harness.rb

@@ -2,42 +2,36 @@ require 'thor'
 require 'hashie'
 require 'roo_on_rails/checks/environment'
 require 'roo_on_rails/environment'
-require 'roo_on_rails/checks/sidekiq/settings'
-require 'roo_on_rails/checks/documentation/playbook'
+require 'roo_on_rails/checks/environment_independent'
 
 module RooOnRails
   class Harness
     include Thor::Shell
 
-    def initialize(try_fix: false, context: Hashie::Mash.new, dry_run: false)
+    def initialize(try_fix: false, environments: nil, context: Hashie::Mash.new, dry_run: false)
       @try_fix = try_fix
       @context = context
       @dry_run = dry_run
+      @environments = environments
     end
 
     def run
       checks = [
-        Checks::Sidekiq::Settings.new(fix: @try_fix, context: @context, dry_run: @dry_run),
-        Checks::Documentation::Playbook.new(fix: @try_fix, context: @context, dry_run: @dry_run),
+        Checks::EnvironmentIndependent.new(fix: @try_fix, context: @context, dry_run: @dry_run),
       ]
       environments.each do |env|
         checks << Checks::Environment.new(env: env.strip, fix: @try_fix, context: @context, dry_run: @dry_run)
       end
 
-      checks.each(&:run)
-      self
-    rescue Shell::CommandFailed
-      say 'A command failed to run, aborting', %i[bold red]
-      exit 2
-    rescue Checks::Failure
-      say 'A check failed, exiting', %i[bold red]
-      exit 1
+      return if checks.map(&:run).all?
+      say 'At least one check failed.', %i[bold red]
     end
 
     private
 
     def environments
-      ENV.fetch('ROO_ON_RAILS_ENVIRONMENTS', 'staging,production').split(',')
+      as_string = @environments || ENV.fetch('ROO_ON_RAILS_ENVIRONMENTS', 'staging,production')
+      as_string.split(',')
     end
   end
 end

data/lib/roo_on_rails/logfmt.rb

@@ -7,10 +7,6 @@ module RooOnRails
   # @see https://godoc.org/github.com/kr/logfmt The 'reference' parser
   module Logfmt
     class << self
-      SPACE = 0x20
-      QUOTE = 0x22
-      EQUALS = 0x3d
-
       def dump(hash)
         return nil if hash.nil? || hash.empty?
 
@@ -26,18 +22,10 @@ module RooOnRails
               when Array, Hash then JSON.dump(v)
               else v.respond_to?(:to_json) ? v.to_json : v.inspect
               end
-        escape(str)
-      end
-
-      def escape(str)
-        return str if ident?(str)
-
-        escaped = str.gsub(/(["\\])/, '\\\\\1')
-        %("#{escaped}")
-      end
 
-      def ident?(str)
-        str.bytes.all? { |b| b > SPACE && b != EQUALS && b != QUOTE }
+        @_escape_re ||= /[[:space:]"']/
+        return str unless @_escape_re =~ str
+        str.inspect
       end
     end
   end

data/lib/roo_on_rails/logger.rb

@@ -0,0 +1,104 @@
+require 'logger'
+require 'delegate'
+require 'roo_on_rails/logfmt'
+
+module RooOnRails
+  # A compatible replacement for the standard Logger to provide context, similar
+  # to `ActiveSupport::TaggedLogging` but with key/value pairs in logfmt format.
+  #
+  #   logger = RooOnRails::Logger.new(STDOUT)
+  #   logger.with(a: 1, b: 2) { logger.info 'Stuff' }
+  #   # Logs "at=INFO msg=Stuff a=1 b=2"
+  #
+  #   logger.with(a: 1) { logger.with(b: 2) { logger.info('Stuff') } }
+  #   # Logs "at=INFO msg=Stuff a=1 b=2"
+  #
+  # The above methods persist the context in thread local storage so it will be
+  # attached to any logs made within the scope of the block, even in called
+  # methods. However, if your context only applies to the current log then you
+  # can chain off the `with` method.
+  #
+  #   logger.with(a: 1, b: 2).info('Stuff')
+  #   # Logs "at=INFO msg=Stuff a=1 b=2"
+  #
+  #   logger.with(a: 1) { logger.with(b: 2).info('Stuff')  }
+  #   # Logs "at=INFO msg=Stuff a=1 b=2"
+  #
+  # Hashes, arrays and any complex object that supports `#to_json` will be
+  # output in escaped JSON format so that it can be parsed out of the attribute
+  # values.
+  class Logger < SimpleDelegator
+    def initialize(io = STDOUT)
+      @show_timestamp = io.tty?
+      logger = ::Logger.new(io).tap do |l|
+        l.formatter = method(:_formatter)
+      end
+      super(logger)
+      set_log_level
+    end
+
+    def with(context = {})
+      return Proxy.new(self, context) unless block_given?
+
+      new_context = (_context_stack.last || {}).merge(context)
+      Thread.handle_interrupt(Exception => :never) do
+        begin
+          _context_stack.push(new_context)
+          Thread.handle_interrupt(Exception => :immediate) do
+            yield self
+          end
+        ensure
+          _context_stack.pop
+        end
+      end
+      nil
+    end
+
+    def set_log_level
+      self.level = ::Logger::Severity.const_get(ENV.fetch('LOG_LEVEL', 'DEBUG'))
+    end
+
+    private
+
+    class Proxy < SimpleDelegator
+      def initialize(logger, context)
+        @context = context
+        super(logger)
+      end
+
+      %w(add debug info warn error fatal unknown).each do |name|
+        define_method name do |*args, &block|
+          __getobj__.with(@context) do
+            __getobj__.public_send(name, *args, &block)
+          end
+        end
+      end
+    end
+
+    private_constant :Proxy
+
+    TIMESTAMP_FORMAT = '%F %T.%L'.freeze
+
+    def _formatter(severity, datetime, _progname, message)
+      if @show_timestamp
+        "[%s] %7s | %s %s\n" % [
+          datetime.utc.strftime(TIMESTAMP_FORMAT),
+          severity,
+          message,
+          Logfmt.dump(_context_stack.last)
+        ]
+      else
+        "%s\n" % Logfmt.dump({
+          at:   severity,
+          msg:  message
+        }.merge(_context_stack.last))
+      end
+    end
+
+    def _context_stack
+      # We use our object ID here to avoid conflicting with other instances
+      thread_key = @_context_stack_key ||= "roo_on_rails:logging_context:#{object_id}".freeze
+      Thread.current[thread_key] ||= [{}]
+    end
+  end
+end

data/lib/roo_on_rails/railties/database.rb

@@ -3,14 +3,16 @@ module RooOnRails
     class Database < Rails::Railtie
       initializer 'roo_on_rails.database', after: 'active_record.initialize_database' do
         ActiveSupport.on_load :active_record do
-          $stderr.puts 'initializer roo_on_rails.database'
+          Rails.logger.with(initializer: 'roo_on_rails.database') do |log|
+            log.debug 'loading'
 
-          config = ActiveRecord::Base.configurations[Rails.env]
-          config['variables'] ||= {}
-          config['variables']['statement_timeout'] = ENV.fetch('DATABASE_STATEMENT_TIMEOUT', 200)
-          config['reaping_frequency'] = ENV['DATABASE_REAPING_FREQUENCY']
+            config = ActiveRecord::Base.configurations[Rails.env]
+            config['variables'] ||= {}
+            config['variables']['statement_timeout'] = ENV.fetch('DATABASE_STATEMENT_TIMEOUT', 200)
+            config['reaping_frequency'] = ENV['DATABASE_REAPING_FREQUENCY']
 
-          ActiveRecord::Base.establish_connection
+            ActiveRecord::Base.establish_connection
+          end
         end
       end
     end

data/lib/roo_on_rails/railties/env.rb

@@ -0,0 +1,11 @@
+module RooOnRails
+  class Railtie < Rails::Railtie
+    initializer 'roo_on_rails.default_env' do
+      Rails.logger.with initializer: 'roo_on_rails.default_env' do |log|
+        log.debug 'loading'
+        require 'roo_on_rails/environment'
+        RooOnRails::Environment.load
+      end
+    end
+  end
+end

data/lib/roo_on_rails/railties/google_oauth.rb

@@ -4,8 +4,9 @@ module RooOnRails
   module Railties
     class GoogleOAuth < Rails::Railtie
       initializer 'roo_on_rails.google_auth.middleware' do |app|
-        $stderr.puts 'initializer roo_on_rails.google_auth'
-        _if_enabled do
+        Rails.logger.with initializer: 'roo_on_rails.google_auth' do |log|
+          next unless Config.google_auth_enabled?
+          log.debug 'loading'
           _add_middleware(app)
           _add_routes(app)
         end
@@ -13,11 +14,6 @@ module RooOnRails
 
       private
 
-      def _if_enabled
-        return unless Config.google_auth_enabled?
-        yield
-      end
-
       def _add_middleware(app)
         require 'omniauth'
         require 'omniauth-google-oauth2'

data/lib/roo_on_rails/railties/http.rb

@@ -2,40 +2,44 @@ module RooOnRails
   module Railties
     class HTTP < Rails::Railtie
       initializer 'roo_on_rails.http' do |app|
-        $stderr.puts 'initializer roo_on_rails.http'
-        require 'rack/timeout/base'
-        require 'rack/ssl-enforcer'
+        Rails.logger.with initializer: 'roo_on_rails.http' do |log|
+          log.debug 'loading'
 
-        require 'roo_on_rails/rack/safe_timeouts'
+          require 'rack/timeout/base'
+          require 'rack/ssl-enforcer'
+          require 'roo_on_rails/rack/safe_timeouts'
 
-        ::Rack::Timeout.service_timeout = ENV.fetch('RACK_SERVICE_TIMEOUT', 15).to_i
-        ::Rack::Timeout.wait_timeout = ENV.fetch('RACK_WAIT_TIMEOUT', 30).to_i
-        ::Rack::Timeout::Logger.level = Logger::WARN
+          ::Rack::Timeout.service_timeout = ENV.fetch('RACK_SERVICE_TIMEOUT', 15).to_i
+          ::Rack::Timeout.wait_timeout = ENV.fetch('RACK_WAIT_TIMEOUT', 30).to_i
+          ::Rack::Timeout::Logger.level = ::Logger::WARN
 
-        app.config.middleware.insert_before(
-          ::Rack::Runtime,
-          ::Rack::Timeout
-        )
+          app.config.middleware.insert_before(
+            ::Rack::Runtime,
+            ::Rack::Timeout
+          )
 
-        middleware_to_insert_before = Rails::VERSION::MAJOR < 4 ? ::ActionDispatch::Cookies : ::Rack::Head 
+          middleware_to_insert_before = Rails::VERSION::MAJOR < 4 ? ::ActionDispatch::Cookies : ::Rack::Head 
 
-        # This needs to be inserted low in the stack, before Rails returns the
-        # thread-current connection to the pool.
-        app.config.middleware.insert_before(
-          middleware_to_insert_before,
-          RooOnRails::Rack::SafeTimeouts
-        )
+          # This needs to be inserted low in the stack, before Rails returns the
+          # thread-current connection to the pool.
+          if defined?(ActiveRecord)
+            app.config.middleware.insert_before(
+              middleware_to_insert_before,
+              RooOnRails::Rack::SafeTimeouts
+            )
+          end
 
-        if ENV.fetch('ROO_ON_RAILS_RACK_DEFLATE', 'YES').to_s =~ /\A(YES|TRUE|ON|1)\Z/i
-          app.config.middleware.use ::Rack::Deflater
-        end
+          if ENV.fetch('ROO_ON_RAILS_RACK_DEFLATE', 'YES').to_s =~ /\A(YES|TRUE|ON|1)\Z/i
+            app.config.middleware.use ::Rack::Deflater
+          end
 
-        # Don't use SslEnforcer in test environment as it breaks Capybara
-        unless Rails.env.test?
-          app.config.middleware.insert_before(
-            middleware_to_insert_before,
-            ::Rack::SslEnforcer
-          )
+          # Don't use SslEnforcer in test environment as it breaks Capybara
+          unless Rails.env.test?
+            app.config.middleware.insert_before(
+              middleware_to_insert_before,
+              ::Rack::SslEnforcer
+            )
+          end
         end
       end
     end

data/lib/roo_on_rails/railties/logging.rb

@@ -0,0 +1,16 @@
+module RooOnRails
+  module Railties
+    class Logging < Rails::Railtie
+      initializer 'roo_on_rails.logging.before', before: :initialize_logger do
+        require 'roo_on_rails/logger'
+        Rails.logger = config.logger = RooOnRails::Logger.new
+        Rails.logger.debug 'initializer roo_on_rails.logging.before'
+      end
+
+      initializer 'roo_on_rails.logging.after', after: :initialize_logger do
+        Rails.logger.set_log_level
+        Rails.logger.debug 'initializer roo_on_rails.logging.after'
+      end
+    end
+  end
+end

data/lib/roo_on_rails/railties/new_relic.rb

@@ -2,25 +2,26 @@ module RooOnRails
   module Railties
     class NewRelic < Rails::Railtie
       initializer 'roo_on_rails.new_relic' do
-        $stderr.puts 'initializer roo_on_rails.new_relic'
+        Rails.logger.with initializer: 'roo_on_rails.new_relic' do |log|
+          log.debug 'loading'
+          license_key = ENV['NEW_RELIC_LICENSE_KEY']
 
-        license_key = ENV['NEW_RELIC_LICENSE_KEY']
+          if %w(test development).exclude?(Rails.env.to_s) && (license_key == 'override-me')
+            abort 'Aborting: NEW_RELIC_LICENSE_KEY must be set in production environments'
+          end
 
-        if %w(test development).exclude?(Rails.env.to_s) && (license_key == 'override-me')
-          abort 'Aborting: NEW_RELIC_LICENSE_KEY must be set in production environments'
-        end
+          abort 'Aborting: NEW_RELIC_LICENSE_KEY is required' if license_key.nil?
 
-        abort 'Aborting: NEW_RELIC_LICENSE_KEY is required' if license_key.nil?
+          path = %w(newrelic.yml config/newrelic.yml).map do |p|
+            Pathname.new(p)
+          end.find(&:exist?)
+          if path
+            abort "Aborting: newrelic.yml detected in '#{path.parent.realpath}', should not exist"
+          end
 
-        path = %w(newrelic.yml config/newrelic.yml).map do |p|
-          Pathname.new(p)
-        end.find(&:exist?)
-        if path
-          abort "Aborting: newrelic.yml detected in '#{path.parent.realpath}', should not exist"
+          require 'newrelic_rpm'
+          ::NewRelic::Agent.manual_start unless Rails.env.test?
         end
-
-        require 'newrelic_rpm'
-        ::NewRelic::Agent.manual_start unless Rails.env.test?
       end
     end
   end

data/lib/roo_on_rails/railties/rake_tasks.rb

@@ -2,8 +2,6 @@ module RooOnRails
   module Railties
     class RakeTasks < Rails::Railtie
       rake_tasks do
-        $stderr.puts 'initializer roo_on_rails.rake_tasks'
-
         Dir[File.join(__dir__, '..', 'tasks', '*.rake')].each { |f| load f }
       end
     end

data/lib/roo_on_rails/railties/routemaster.rb

@@ -4,17 +4,18 @@ module RooOnRails
   module Railties
     class Routemaster < Rails::Railtie
       initializer 'roo_on_rails.routemaster' do
-        next unless Config.routemaster_enabled?
+        Rails.logger.with initializer: 'roo_on_rails.routemaster' do |log|
+          next unless Config.routemaster_enabled?
+          log.debug 'loading'
 
-        $stderr.puts 'initializer roo_on_rails.routemaster'
+          abort 'Aborting: ROUTEMASTER_URL and ROUTEMASTER_UUID are required' if bus_details_missing?
 
-        abort 'Aborting: ROUTEMASTER_URL and ROUTEMASTER_UUID are required' if bus_details_missing?
+          require 'routemaster/client'
 
-        require 'routemaster/client'
-
-        ::Routemaster::Client.configure do |config|
-          config.url = routemaster_url
-          config.uuid = routemaster_uuid
+          ::Routemaster::Client.configure do |config|
+            config.url = routemaster_url
+            config.uuid = routemaster_uuid
+          end
         end
       end
 

data/lib/roo_on_rails/railties/sidekiq.rb

@@ -8,21 +8,25 @@ module RooOnRails
   module Railties
     class Sidekiq < Rails::Railtie
       initializer 'roo_on_rails.sidekiq' do |app|
-        require 'hirefire-resource'
-        
-        if RooOnRails::Config.sidekiq_enabled?
-          $stderr.puts 'initializer roo_on_rails.sidekiq'
+        Rails.logger.with initializer: 'roo_on_rails.sidekiq' do |log|
+          
+          unless RooOnRails::Config.sidekiq_enabled?
+            logger.debug 'skipping'
+            next
+          end
+
+          log.debug 'loading'
+          require 'hirefire-resource'
+         
           config_sidekiq
           config_sidekiq_metrics
           config_hirefire(app)
-        else
-          $stderr.puts 'skipping initializer roo_on_rails.sidekiq'
         end
       end
 
       def config_hirefire(app)
         unless ENV['HIREFIRE_TOKEN']
-          warn 'No HIREFIRE_TOKEN token set, auto scaling not enabled'
+          Rails.logger.warn 'No HIREFIRE_TOKEN token set, auto scaling not enabled'
           return
         end
         add_middleware(app)
@@ -44,7 +48,7 @@ module RooOnRails
           end
         end
       rescue LoadError
-        $stderr.puts 'Sidekiq metrics unavailable without Sidekiq Pro'
+        Rails.logger.warn 'Sidekiq metrics unavailable without Sidekiq Pro'
       end
 
       def add_middleware(app)

data/lib/roo_on_rails/routemaster/publisher.rb

@@ -22,7 +22,14 @@ module RooOnRails
 
       def publish!
         return unless will_publish?
-        @client.send(@event, topic, url, async: async?, data: stringify_keys(data))
+        @client.send(
+          @event,
+          topic,
+          url,
+          async: async?,
+          data: stringify_keys(data),
+          t: timestamp && timestamp.to_i
+        )
       end
 
       def topic
@@ -41,6 +48,12 @@ module RooOnRails
         nil
       end
 
+      def timestamp
+        return @model.created_at if created? && @model.respond_to?(:created_at)
+        return @model.updated_at if (updated? || created?) && @model.respond_to?(:updated_at)
+        nil
+      end
+
       %i(created updated deleted noop).each do |event_type|
         define_method :"#{event_type}?" do
           @event.to_sym == event_type

data/lib/roo_on_rails/routemaster/publishers.rb

@@ -9,12 +9,12 @@ module RooOnRails
       end
 
       def self.register(publisher_class, model_class:)
-        @publishers[model_class] ||= Set.new
-        @publishers[model_class] << publisher_class
+        @publishers[model_class.name] ||= Set.new
+        @publishers[model_class.name] << publisher_class
       end
 
       def self.for(model, event)
-        publisher_classes = @publishers[model.class] || @default_publishers
+        publisher_classes = @publishers[model.class.name] || @default_publishers
         publisher_classes.map { |c| c.new(model, event) }
       end
 

data/lib/roo_on_rails/sidekiq/process_scaling.rb

@@ -15,7 +15,7 @@ module RooOnRails
 
       def current_processes
         ::Sidekiq::ProcessSet.new.count do |process|
-          process['quiet'] == 'false' &&
+          process['quiet'].to_s == 'false' &&
           @queue_names.any? do |queue_name|
             process['queues'].include?(queue_name)
           end

data/lib/roo_on_rails/tasks/db.rake

@@ -18,12 +18,13 @@ if defined?(ActiveRecord)
     end
   end
 
-  %i[
+  %i(
     db:create
+    db:drop
     db:migrate
     db:migrate:down
     db:rollback
-  ].each do |task|
+  ).each do |task|
     Rake::Task[task].enhance(%i[db:migrate:extend_statement_timeout])
   end
 end

data/lib/roo_on_rails/version.rb

@@ -1,3 +1,3 @@
 module RooOnRails
-  VERSION = '1.10.0'.freeze
+  VERSION = '1.11.0'.freeze
 end

data/lib/roo_on_rails.rb

@@ -5,7 +5,8 @@ end
 
 if defined?(Rails)
   require 'dotenv/rails-now'
-  require 'roo_on_rails/railtie'
+  require 'roo_on_rails/railties/logging'
+  require 'roo_on_rails/railties/env'
   require 'roo_on_rails/railties/new_relic'
   require 'roo_on_rails/railties/database'
   require 'roo_on_rails/railties/http'