appsignal 0.6.7 → 0.7.0.alpha.1

data/lib/appsignal/aggregator.rb

@@ -2,7 +2,7 @@ module Appsignal
   class Aggregator
     attr_reader :queue, :slowness_index, :counts
 
-    def initialize(queue = [], slowness_index = {})
+    def initialize(queue=::ThreadSafe::Array.new, slowness_index={})
       @queue = queue
       @slowness_index = slowness_index
       @counts = {:regular_request => 0, :slow_request => 0, :exception => 0}
@@ -37,7 +37,7 @@ module Appsignal
     # @returns [ Array ] Array of post processed Appsignal::Transaction objects
     def post_processed_queue!
       Appsignal.logger.debug("Post processing queue: #{counts.inspect}")
-      Appsignal::PostProcessor.new(queue).post_processed_queue!
+      Appsignal::Aggregator::PostProcessor.new(queue).post_processed_queue!
     end
 
     protected
@@ -63,5 +63,3 @@ module Appsignal
     end
   end
 end
-
-require 'appsignal/aggregator/post_processor'

data/lib/appsignal/aggregator/middleware.rb

@@ -0,0 +1,4 @@
+require 'appsignal/aggregator/middleware/chain'
+require 'appsignal/aggregator/middleware/delete_blanks'
+require 'appsignal/aggregator/middleware/action_view_sanitizer'
+require 'appsignal/aggregator/middleware/active_record_sanitizer'

data/lib/appsignal/aggregator/middleware/action_view_sanitizer.rb

@@ -0,0 +1,23 @@
+module Appsignal
+  class Aggregator
+    module Middleware
+      class ActionViewSanitizer
+        TARGET_EVENT_CATEGORY = 'action_view'.freeze
+
+        def call(event)
+          if event.name.end_with?(TARGET_EVENT_CATEGORY)
+            identifier = event.payload[:identifier]
+            if identifier
+              identifier.gsub!(root_path, '')
+            end
+          end
+          yield
+        end
+
+        def root_path
+          @root_path ||= "#{Rails.root.to_s}/"
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/aggregator/middleware/active_record_sanitizer.rb

@@ -0,0 +1,64 @@
+module Appsignal
+  class Aggregator
+    module Middleware
+      class ActiveRecordSanitizer
+        TARGET_EVENT_NAME = 'sql.active_record'.freeze
+
+        SINGLE_QUOTE       = /\\'/.freeze
+        DOUBLE_QUOTE       = /\\"/.freeze
+        QUOTED_DATA        = /(?:"[^"]+"|'[^']+')/.freeze
+        SINGLE_QUOTED_DATA = /(?:'[^']+')/.freeze
+        IN_ARRAY           = /(IN \()[^\)]+(\))/.freeze
+        NUMERIC_DATA       = /\b\d+\b/.freeze
+
+        SANITIZED_VALUE = '\1?\2'.freeze
+
+        def call(event)
+          if event.name == TARGET_EVENT_NAME
+            unless schema_query?(event) || adapter_uses_prepared_statements?
+              query_string = event.payload[:sql]
+              if query_string
+                if adapter_uses_double_quoted_table_names?
+                  query_string.gsub!(SINGLE_QUOTE, SANITIZED_VALUE)
+                  query_string.gsub!(SINGLE_QUOTED_DATA, SANITIZED_VALUE)
+                else
+                  query_string.gsub!(SINGLE_QUOTE, SANITIZED_VALUE)
+                  query_string.gsub!(DOUBLE_QUOTE, SANITIZED_VALUE)
+                  query_string.gsub!(QUOTED_DATA, SANITIZED_VALUE)
+                end
+                query_string.gsub!(IN_ARRAY, SANITIZED_VALUE)
+                query_string.gsub!(NUMERIC_DATA, SANITIZED_VALUE)
+              end
+            end
+            event.payload.delete(:connection_id)
+            event.payload.delete(:binds)
+          end
+          yield
+        end
+
+        def schema_query?(event)
+          event.payload[:name] == 'SCHEMA'
+        end
+
+        def connection_config
+          @connection_config ||= if ActiveRecord::Base.respond_to?(:connection_config)
+            ActiveRecord::Base.connection_config
+          else
+            ActiveRecord::Base.connection_pool.spec.config
+          end
+        end
+
+        def adapter_uses_double_quoted_table_names?
+          adapter = connection_config[:adapter]
+          adapter =~ /postgres/ || adapter =~ /sqlite/
+        end
+
+        def adapter_uses_prepared_statements?
+          return false unless adapter_uses_double_quoted_table_names?
+          return true if connection_config[:prepared_statements].nil?
+          connection_config[:prepared_statements]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/aggregator/middleware/chain.rb

@@ -0,0 +1,101 @@
+module Appsignal
+  class Aggregator
+    # Middleware is code configured to run before/after a message is processed.
+    # It is patterned after Rack middleware.
+    #
+    # @example To add middleware:
+    #
+    #   Appsignal.post_processing_middleware do |chain|
+    #     chain.add MyPostProcessingHook
+    #   end
+    #
+    # @example To insert immediately preceding another entry:
+    #
+    #   Appsignal.post_process_middleware do |chain|
+    #     chain.insert_before ActiveRecord, MyPostProcessingHook
+    #   end
+    #
+    # @example To insert immediately after another entry:
+    #
+    #   Appsignal.post_process_middleware do |chain|
+    #     chain.insert_after ActiveRecord, MyPostProcessingHook
+    #   end
+    #
+    # @example This is an example of a minimal middleware class:
+    #
+    #   class MySHook
+    #     def call(transaction)
+    #       puts "Before post processing"
+    #       yield
+    #       puts "After post processing"
+    #     end
+    #   end
+    #
+    module Middleware
+      class Chain
+        attr_reader :entries
+
+        def initialize
+          @entries = []
+          yield self if block_given?
+        end
+
+        def remove(klass)
+          entries.delete_if { |entry| entry.klass == klass }
+        end
+
+        def add(klass, *args)
+          entries << Entry.new(klass, *args) unless exists?(klass)
+        end
+
+        def insert_before(oldklass, newklass, *args)
+          i = entries.index { |entry| entry.klass == newklass }
+          new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+          i = entries.find_index { |entry| entry.klass == oldklass } || 0
+          entries.insert(i, new_entry)
+        end
+
+        def insert_after(oldklass, newklass, *args)
+          i = entries.index { |entry| entry.klass == newklass }
+          new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+          i = entries.find_index { |entry| entry.klass == oldklass } || entries.count - 1
+          entries.insert(i+1, new_entry)
+        end
+
+        def exists?(klass)
+          entries.any? { |entry| entry.klass == klass }
+        end
+
+        def retrieve
+          @retrieve ||= entries.map(&:make_new)
+        end
+
+        def clear
+          entries.clear
+        end
+
+        def invoke(*args)
+          chain = retrieve.dup
+          traverse_chain = lambda do
+            unless chain.empty?
+              chain.shift.call(*args, &traverse_chain)
+            end
+          end
+          traverse_chain.call
+        end
+      end
+
+      class Entry
+        attr_reader :klass
+        def initialize(klass, *args)
+          @klass = klass
+          @args  = args
+        end
+
+        def make_new
+          @klass.new(*@args)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/aggregator/middleware/delete_blanks.rb

@@ -0,0 +1,16 @@
+module Appsignal
+  class Aggregator
+    module Middleware
+      class DeleteBlanks
+        def call(event)
+          event.payload.each do |key, value|
+            if value.respond_to?(:empty?) ? value.empty? : !value
+              event.payload.delete(key)
+            end
+          end
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/aggregator/post_processor.rb

@@ -1,27 +1,30 @@
 module Appsignal
-  class PostProcessor
-    attr_reader :transactions
+  class Aggregator
+    class PostProcessor
+      attr_reader :transactions
 
-    def initialize(transactions)
-      @transactions = transactions
-    end
+      def initialize(transactions)
+        @transactions = transactions
+      end
 
-    def post_processed_queue!
-      transactions.map do |transaction|
-        transaction.events.each do |event|
-          Appsignal.post_processing_middleware.invoke(event)
+      def post_processed_queue!
+        transactions.map do |transaction|
+          transaction.events.each do |event|
+            Appsignal.post_processing_middleware.invoke(event)
+          end
+          transaction.to_hash
         end
-        transaction.to_hash
       end
-    end
 
-    def self.default_middleware
-      Middleware::Chain.new do |chain|
-        chain.add Appsignal::Middleware::DeleteBlanks
-        chain.add Appsignal::Middleware::ActionViewSanitizer
-        if defined?(ActiveRecord)
-          require 'appsignal/middleware/active_record_sanitizer'
-          chain.add Appsignal::Middleware::ActiveRecordSanitizer
+      def self.default_middleware
+        Middleware::Chain.new do |chain|
+          chain.add Appsignal::Aggregator::Middleware::DeleteBlanks
+          if defined?(::ActionView)
+            chain.add Appsignal::Aggregator::Middleware::ActionViewSanitizer
+          end
+          if defined?(::ActiveRecord)
+            chain.add Appsignal::Aggregator::Middleware::ActiveRecordSanitizer
+          end
         end
       end
     end

data/lib/appsignal/auth_check.rb

@@ -2,29 +2,15 @@ module Appsignal
   class AuthCheck
     ACTION = 'auth'.freeze
 
-    attr_reader :environment, :logger
-    attr_accessor :transmitter
+    attr_reader :config, :logger
 
-    def initialize(*args)
-      @environment = args.shift
-      options = args.empty? ? {} : args.last
-      @config = options[:config]
-      @logger = options[:logger]
-    end
-
-    def uri
-      transmitter.uri
-    end
-
-    def config
-      @config ||= Appsignal::Config.new(Rails.root, environment, logger).load
+    def initialize(config, logger)
+      @config = config
+      @logger = logger
     end
 
     def perform
-      self.transmitter = Appsignal::Transmitter.new(
-        config[:endpoint], ACTION, config[:api_key]
-      )
-      transmitter.transmit({})
+      Appsignal::Transmitter.new(ACTION, config).transmit({})
     end
 
     def perform_with_result
@@ -37,12 +23,12 @@ module Appsignal
           result = 'API key not valid with AppSignal...'
         else
           result = 'Could not confirm authorization: '\
-            "#{status.nil? ? 'nil' : status}"
+                   "#{status.nil? ? 'nil' : status}"
         end
         [status, result]
       rescue Exception => e
         result = 'Something went wrong while trying to '\
-          "authenticate with AppSignal: #{e}"
+                 "authenticate with AppSignal: #{e}"
         [nil, result]
       end
     end

data/lib/appsignal/capistrano.rb

@@ -1,37 +1,2 @@
-require 'capistrano'
 require 'appsignal'
-
-module Appsignal
-  class Capistrano
-    def self.tasks(config)
-      config.load do
-        after "deploy", "appsignal:deploy"
-        after "deploy:migrations", "appsignal:deploy"
-
-        namespace :appsignal do
-          task :deploy do
-            rails_env = fetch(:rails_env, 'production')
-            user = ENV['USER'] || ENV['USERNAME']
-
-            marker_data = {
-              :revision => current_revision,
-              :repository => repository,
-              :user => user
-            }
-
-            marker = Marker.new(marker_data, ENV['PWD'], rails_env, logger)
-            if config.dry_run
-              logger.info("Dry run: Deploy marker not actually sent.")
-            else
-              marker.transmit
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-if Capistrano::Configuration.instance
-  Appsignal::Capistrano.tasks(Capistrano::Configuration.instance)
-end
+require 'appsignal/integrations/capistrano'

data/lib/appsignal/cli.rb

@@ -5,21 +5,15 @@ require 'appsignal'
 
 module Appsignal
   class CLI
-    AVAILABLE_COMMANDS = %w(notify_of_deploy api_check).freeze
-    PROJECT_ROOT = ENV['PWD']
+    AVAILABLE_COMMANDS = %w(notify_of_deploy).freeze
 
     class << self
-      def run(argv=ARGV)
-        unless File.exists?(File.join(PROJECT_ROOT, 'config/appsignal.yml'))
-          puts 'No config file present at config/appsignal.yml'
-          puts 'Log in to https://appsignal.com to get instructions on how to '\
-            'generate the config file.'
-          exit(1)
-        end
-        options = {}
-        global = global_option_parser(options)
-        commands = command_option_parser(options)
+      attr_accessor :options, :config
 
+      def run(argv=ARGV)
+        @options = {}
+        global = global_option_parser
+        commands = command_option_parser
         global.order!(argv)
         command = argv.shift
         if command
@@ -27,9 +21,7 @@ module Appsignal
             commands[command].parse!(argv)
             case command.to_sym
             when :notify_of_deploy
-              notify_of_deploy(options)
-            when :api_check
-              api_check
+              notify_of_deploy
             end
           else
             puts "Command '#{command}' does not exist, run appsignal -h to "\
@@ -47,7 +39,15 @@ module Appsignal
         Logger.new($stdout)
       end
 
-      def global_option_parser(options)
+      def config
+        @config ||= Appsignal::Config.new(
+          ENV['PWD'],
+          options[:environment],
+          logger
+        )
+      end
+
+      def global_option_parser
         OptionParser.new do |o|
           o.banner = 'Usage: appsignal <command> [options]'
 
@@ -66,7 +66,7 @@ module Appsignal
         end
       end
 
-      def command_option_parser(options)
+      def command_option_parser
         {
           'notify_of_deploy' => OptionParser.new do |o|
             o.banner = 'Usage: appsignal notify_of_deploy [options]'
@@ -86,51 +86,28 @@ module Appsignal
             o.on '--environment=<rails_env>', "The environment you're deploying to" do |arg|
               options[:environment] = arg
             end
-          end,
-          'api_check' => OptionParser.new do |o|
-            o.banner = %q(Usage: appsignal api_check
-
-            This command checks the config file in config/appsignal.yml
-            and tries to use the api_keys available in each environment to
-            see if they work.)
           end
         }
       end
 
-      def notify_of_deploy(options)
-        validate_required_options([:revision, :repository, :user, :environment], options)
+      def notify_of_deploy
+        validate_config_loaded
+        validate_required_options([:revision, :repository, :user, :environment])
+
         Appsignal::Marker.new(
           {
             :revision => options[:revision],
             :repository => options[:repository],
             :user => options[:user]
           },
-          PROJECT_ROOT,
-          options[:environment],
+          config,
           logger
         ).transmit
       end
 
-      def api_check
-        puts "\nReading config/appsignal.yml and attempting to use the config "\
-          "in order to check if it is set up the way it should be.\n\n"
-        Appsignal::Config.new(
-          PROJECT_ROOT, '', logger
-        ).load_all.each do |env, config|
-          auth_check = ::Appsignal::AuthCheck.new(
-            env,
-            {:config => config, :logger => logger}
-          )
-          puts "[#{env}]"
-          puts '  * Configured not to monitor this environment' unless config[:active]
-          status, result = auth_check.perform_with_result
-          puts "  * #{result}"
-        end
-      end
-
       protected
 
-      def validate_required_options(required_options, options)
+      def validate_required_options(required_options)
         missing = required_options.select do |required_option|
           options[required_option].blank?
         end
@@ -139,6 +116,13 @@ module Appsignal
           exit(1)
         end
       end
+
+      def validate_config_loaded
+        unless config.loaded?
+          puts 'Exiting: No config file or push api key env var found'
+          exit(1)
+        end
+      end
     end
   end
 end