appsignal 0.11.18 → 0.12.beta.0

data/lib/appsignal.rb

@@ -1,22 +1,19 @@
 require 'logger'
-require 'rack'
-require 'thread_safe'
 require 'securerandom'
 
 begin
   require 'active_support/notifications'
-rescue LoadError
+  ActiveSupport::Notifications::Fanout::Subscribers::Timed # See it it's recent enough
+rescue LoadError, NameError
   require 'vendor/active_support/notifications'
 end
 
 module Appsignal
   class << self
-    attr_accessor :config, :logger, :agent, :in_memory_log
+    attr_accessor :config, :subscriber, :logger, :agent, :in_memory_log
 
     def load_integrations
       require 'appsignal/integrations/delayed_job'
-      require 'appsignal/integrations/passenger'
-      require 'appsignal/integrations/unicorn'
       require 'appsignal/integrations/sidekiq'
       require 'appsignal/integrations/resque'
       require 'appsignal/integrations/sequel'
@@ -47,14 +44,13 @@ module Appsignal
         end
         if config.active?
           logger.info("Starting AppSignal #{Appsignal::VERSION} on #{RUBY_VERSION}/#{RUBY_PLATFORM}")
+          config.write_to_environment
+          Appsignal::Extension.start
           load_integrations
           load_instrumentations
+          Appsignal::EventFormatter.initialize_formatters
           initialize_extensions
-          @agent = Appsignal::Agent.new
-          at_exit do
-            logger.debug('Running at_exit block')
-            @agent.send_queue
-          end
+          @subscriber = Appsignal::Subscriber.new
         else
           logger.info("Not starting, not active for #{config.env}")
         end
@@ -63,17 +59,6 @@ module Appsignal
       end
     end
 
-    # Convenience method for adding a transaction to the queue. This queue is
-    # managed and is periodically pushed to Appsignal.
-    #
-    # @return [ true ] True.
-    #
-    # @since 0.5.0
-    def enqueue(transaction)
-      return unless active?
-      agent.enqueue(transaction)
-    end
-
     def monitor_transaction(name, payload={})
       unless active?
         yield
@@ -81,12 +66,12 @@ module Appsignal
       end
 
       begin
-        Appsignal::Transaction.create(SecureRandom.uuid, ENV)
+        Appsignal::Transaction.create(SecureRandom.uuid, ENV.to_hash)
         ActiveSupport::Notifications.instrument(name, payload) do
           yield
         end
-      rescue Exception => exception
-        Appsignal.add_exception(exception)
+      rescue => exception
+        Appsignal.set_exception(exception)
         raise exception
       ensure
         Appsignal::Transaction.complete_current!
@@ -102,23 +87,18 @@ module Appsignal
 
     def send_exception(exception, tags=nil)
       return if !active? || is_ignored_exception?(exception)
-      unless exception.is_a?(Exception)
-        logger.error('Can\'t send exception, given value is not an exception')
-        return
-      end
-      transaction = Appsignal::Transaction.create(SecureRandom.uuid, nil)
-      transaction.add_exception(exception)
+      transaction = Appsignal::Transaction.create(SecureRandom.uuid, ENV.to_hash)
       transaction.set_tags(tags) if tags
-      transaction.complete!
-      Appsignal.agent.send_queue
+      transaction.set_error(exception)
+      Appsignal::Transaction.complete_current!
     end
 
-    def add_exception(exception)
+    def set_exception(exception)
       return if !active? ||
                 Appsignal::Transaction.current.nil? ||
                 exception.nil? ||
                 is_ignored_exception?(exception)
-      Appsignal::Transaction.current.add_exception(exception)
+      Appsignal::Transaction.current.set_error(exception)
     end
 
     def tag_request(params={})
@@ -129,10 +109,6 @@ module Appsignal
     end
     alias :tag_job :tag_request
 
-    def transactions
-      @transactions ||= {}
-    end
-
     def logger
       @in_memory_log = StringIO.new unless @in_memory_log
       @logger ||= Logger.new(@in_memory_log).tap do |l|
@@ -157,15 +133,8 @@ module Appsignal
       @logger << @in_memory_log.string if @in_memory_log
     end
 
-    def post_processing_middleware
-      @post_processing_chain ||= Appsignal::Aggregator::PostProcessor.default_middleware
-      yield @post_processing_chain if block_given?
-      @post_processing_chain
-    end
-
     def active?
-      config && config.active? &&
-        agent && agent.active?
+      config && config.active?
     end
 
     def is_ignored_exception?(exception)
@@ -188,25 +157,18 @@ module Appsignal
   end
 end
 
-require 'appsignal/agent'
-require 'appsignal/event'
-require 'appsignal/aggregator'
-require 'appsignal/aggregator/post_processor'
-require 'appsignal/aggregator/middleware'
+require 'appsignal_extension'
 require 'appsignal/auth_check'
 require 'appsignal/config'
+require 'appsignal/event_formatter'
 require 'appsignal/marker'
-require 'appsignal/rack/listener'
-require 'appsignal/rack/instrumentation'
-require 'appsignal/rack/sinatra_instrumentation'
-require 'appsignal/rack/js_exception_catcher'
 require 'appsignal/params_sanitizer'
+require 'appsignal/subscriber'
 require 'appsignal/transaction'
-require 'appsignal/transaction/formatter'
-require 'appsignal/transaction/params_sanitizer'
-require 'appsignal/transmitter'
-require 'appsignal/zipped_payload'
-require 'appsignal/ipc'
 require 'appsignal/version'
+require 'appsignal/rack/js_exception_catcher'
+require 'appsignal/rack/listener'
+require 'appsignal/rack/instrumentation'
 require 'appsignal/integrations/rails'
 require 'appsignal/js_exception_transaction'
+require 'appsignal/transmitter'

data/lib/appsignal/capistrano.rb

@@ -1,7 +1,6 @@
 require 'appsignal'
-require 'capistrano/version'
 
-if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION) >= Gem::Version.new(3)
+if defined?(Capistrano::VERSION)
   # Capistrano 3+
   load File.expand_path('../integrations/capistrano/appsignal.cap', __FILE__)
 else

data/lib/appsignal/config.rb

@@ -10,7 +10,7 @@ module Appsignal
       :ignore_exceptions              => [],
       :ignore_actions                 => [],
       :send_params                    => true,
-      :endpoint                       => 'https://push.appsignal.com/1',
+      :endpoint                       => 'https://push.appsignal.com',
       :slow_request_threshold         => 200,
       :instrument_net_http            => true,
       :skip_session_data              => false,
@@ -67,6 +67,18 @@ module Appsignal
       !! self[:active]
     end
 
+    def write_to_environment
+      ENV['APPSIGNAL_ACTIVE']            = active?.to_s
+      ENV['APPSIGNAL_APP_PATH']          = root_path.to_s
+      ENV['APPSIGNAL_AGENT_PATH']        = File.expand_path('../../../ext', __FILE__).to_s
+      ENV['APPSIGNAL_LOG_PATH']          = File.join(root_path, 'log')
+      ENV['APPSIGNAL_PUSH_API_ENDPOINT'] = config_hash[:endpoint]
+      ENV['APPSIGNAL_PUSH_API_KEY']      = config_hash[:push_api_key]
+      ENV['APPSIGNAL_APP_NAME']          = config_hash[:name]
+      ENV['APPSIGNAL_ENVIRONMENT']       = env
+      ENV['APPSIGNAL_AGENT_VERSION']     = Appsignal::AGENT_VERSION
+    end
+
     protected
 
     def config_file

data/lib/appsignal/event_formatter.rb

@@ -0,0 +1,67 @@
+module Appsignal
+  # Keeps track of formatters for types event that we can use to get
+  # the title and body of an event. Formatters should inherit from this class
+  # and implement a format(payload) method which returns an array with the title
+  # and body.
+  #
+  # When implementing a formatter remember that it cannot keep separate state per
+  # event, the same object will be called intermittently in a threaded environment.
+  # So only keep global configuration as state and pass the payload around as an
+  # argument if you need to use helper methods.
+  class EventFormatter
+    class << self
+      def formatters
+        @@formatters ||= {}
+      end
+
+      def formatter_classes
+        @@formatter_classes ||= {}
+      end
+
+      def register(name, formatter=self)
+        formatter_classes[name] = formatter
+      end
+
+      def unregister(name, formatter=self)
+        if formatter_classes[name] == formatter
+          formatter_classes.delete(name)
+          formatters.delete(name)
+        end
+      end
+
+      def registered?(name, klass=nil)
+        if klass
+          formatter_classes[name] == klass
+        else
+          formatter_classes.include?(name)
+        end
+      end
+
+      def initialize_formatters
+        formatter_classes.each do |name, formatter|
+          begin
+            format_method = formatter.instance_method(:format)
+            if format_method && format_method.arity == 1
+              formatters[name] = formatter.new
+            else
+              raise "#{f} does not have a format(payload) method"
+            end
+          rescue Exception => ex
+            formatter_classes.delete(name)
+            formatters.delete(name)
+            Appsignal.logger.debug("'#{ex.message}' when initializing #{name} event formatter")
+          end
+        end
+      end
+
+      def format(name, payload)
+        formatter = formatters[name]
+        formatter.format(payload) unless formatter.nil?
+      end
+    end
+  end
+end
+
+Dir.glob(File.expand_path('../event_formatter/**/*.rb', __FILE__)).each do |file|
+  require file
+end

data/lib/appsignal/event_formatter/action_view/render_formatter.rb

@@ -0,0 +1,23 @@
+module Appsignal
+  class EventFormatter
+    module ActionView
+      class RenderFormatter < Appsignal::EventFormatter
+        register 'render_partial.action_view'
+        register 'render_template.action_view'
+
+        BLANK = ''.freeze
+
+        attr_reader :root_path
+
+        def initialize
+          @root_path = "#{Rails.root.to_s}/".freeze
+        end
+
+        def format(payload)
+          return nil unless payload[:identifier]
+          [payload[:identifier].sub(root_path, BLANK), nil]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/active_record/sql_formatter.rb

@@ -0,0 +1,74 @@
+module Appsignal
+  class EventFormatter
+    module ActiveRecord
+      class SqlFormatter < Appsignal::EventFormatter
+        register 'sql.active_record'
+
+        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
+
+        attr_reader :adapter_uses_double_quoted_table_names, :adapter_uses_prepared_statements
+
+        def initialize
+          @connection_config = connection_config
+          @adapter_uses_prepared_statements = adapter_uses_prepared_statements?
+          @adapter_uses_double_quoted_table_names = adapter_uses_double_quoted_table_names?
+        rescue ::ActiveRecord::ConnectionNotEstablished
+          Appsignal::EventFormatter.unregister('sql.active_record', self.class)
+          Appsignal.logger.error('Error while getting ActiveRecord connection info, unregistering sql.active_record event formatter')
+        end
+
+        def format(payload)
+          return nil if schema_query?(payload) || !payload[:sql]
+          if adapter_uses_prepared_statements
+            [payload[:name], payload[:sql]]
+          else
+            sql_string = payload[:sql].dup
+            if adapter_uses_double_quoted_table_names
+              sql_string.gsub!(SINGLE_QUOTE, SANITIZED_VALUE)
+              sql_string.gsub!(SINGLE_QUOTED_DATA, SANITIZED_VALUE)
+            else
+              sql_string.gsub!(SINGLE_QUOTE, SANITIZED_VALUE)
+              sql_string.gsub!(DOUBLE_QUOTE, SANITIZED_VALUE)
+              sql_string.gsub!(QUOTED_DATA, SANITIZED_VALUE)
+            end
+            sql_string.gsub!(IN_ARRAY, SANITIZED_VALUE)
+            sql_string.gsub!(NUMERIC_DATA, SANITIZED_VALUE)
+            [payload[:name], sql_string]
+          end
+        end
+
+        protected
+
+          def schema_query?(payload)
+            payload[:name] == 'SCHEMA'
+          end
+
+          def connection_config
+            # TODO handle ActiveRecord::ConnectionNotEstablished
+            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/event_formatter/moped/query_formatter.rb

@@ -0,0 +1,80 @@
+module Appsignal
+  class EventFormatter
+    module Moped
+      class QueryFormatter < Appsignal::EventFormatter
+        register 'query.moped'
+
+        def format(payload)
+          if payload[:ops] && payload[:ops].length > 0
+            op = payload[:ops].first
+            case op.class.to_s
+            when 'Moped::Protocol::Command'
+              return ['Command', {
+                :database => op.full_collection_name,
+                :selector => sanitize(op.selector)
+              }.inspect]
+            when 'Moped::Protocol::Query'
+              return ['Query', {
+                :database => op.full_collection_name,
+                :selector => sanitize(op.selector),
+                :flags    => op.flags,
+                :limit    => op.limit,
+                :skip     => op.skip,
+                :fields   => op.fields
+              }.inspect]
+            when 'Moped::Protocol::Delete'
+              return ['Delete', {
+                :database => op.full_collection_name,
+                :selector => sanitize(op.selector),
+                :flags    => op.flags,
+              }.inspect]
+            when 'Moped::Protocol::Insert'
+              return ['Insert', {
+                :database   => op.full_collection_name,
+                :documents  => sanitize(op.documents),
+                :flags      => op.flags,
+              }.inspect]
+            when 'Moped::Protocol::Update'
+              return ['Update', {
+                :database => op.full_collection_name,
+                :selector => sanitize(op.selector),
+                :update   => sanitize(op.update),
+                :flags    => op.flags,
+              }.inspect]
+            when 'Moped::Protocol::KillCursors'
+              return ['KillCursors', {
+                :number_of_cursor_ids => op.number_of_cursor_ids
+              }.inspect]
+            else
+              return [op.class.to_s.sub('Moped::Protocol::', ''), {
+                :database => op.full_collection_name
+              }.inspect]
+            end
+          end
+        end
+
+        protected
+
+          def sanitize(params)
+            if params.is_a?(Hash)
+              {}.tap do |hsh|
+                params.each do |key, val|
+                  hsh[key] = sanitize(val)
+                end
+              end
+            elsif params.is_a?(Array)
+              if params.first.is_a?(String)
+                ['?']
+              else
+                params.map do |item|
+                  sanitize(item)
+                end
+              end
+            else
+              '?'
+            end
+          end
+        end
+    end
+  end
+end