appsignal 0.11.18 → 0.12.beta.0

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

@@ -1,16 +0,0 @@
-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,32 +0,0 @@
-module Appsignal
-  class Aggregator
-    class PostProcessor
-      attr_reader :transactions
-
-      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)
-          end
-          transaction.to_hash
-        end
-      end
-
-      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
-  end
-end

data/lib/appsignal/event.rb

@@ -1,20 +0,0 @@
-class Appsignal::Event < ActiveSupport::Notifications::Event
-  def sanitize!
-    @payload = Appsignal::ParamsSanitizer.sanitize(@payload)
-  end
-
-  def truncate!
-    @payload = {}
-  end
-
-  def self.event_for_instrumentation(*args)
-    case args[0]
-    when 'query.moped'
-      Appsignal::Event::MopedEvent.new(*args)
-    else
-      new(*args)
-    end
-  end
-end
-
-require 'appsignal/event/moped_event'

data/lib/appsignal/event/moped_event.rb

@@ -1,90 +0,0 @@
-class Appsignal::Event::MopedEvent < Appsignal::Event
-  def initialize(name, start, ending, transaction_id, payload)
-    super(name, start, ending, transaction_id, transform_payload(payload))
-  end
-
-  def transform_payload(payload)
-    if payload[:ops] && payload[:ops].length > 0
-      transformed_ops = [].tap do |arr|
-        payload[:ops].each do |op|
-          arr << payload_from_op(op.dup)
-        end
-      end
-      payload[:ops] = transformed_ops
-    end
-    payload
-  end
-
-  def payload_from_op(payload)
-    case payload.class.to_s
-    when 'Moped::Protocol::Command'
-      {
-        :type     => 'Command',
-        :database => payload.full_collection_name,
-        :selector => sanitize(payload.selector)
-      }
-    when 'Moped::Protocol::Query'
-      {
-        :type     => 'Query',
-        :database => payload.full_collection_name,
-        :selector => sanitize(payload.selector),
-        :flags    => payload.flags,
-        :limit    => payload.limit,
-        :skip     => payload.skip,
-        :fields   => payload.fields
-      }
-    when 'Moped::Protocol::Delete'
-      {
-        :type     => 'Delete',
-        :database => payload.full_collection_name,
-        :selector => sanitize(payload.selector),
-        :flags    => payload.flags,
-      }
-    when 'Moped::Protocol::Insert'
-      {
-        :type       => 'Insert',
-        :database   => payload.full_collection_name,
-        :documents  => sanitize(payload.documents),
-        :flags      => payload.flags,
-      }
-    when 'Moped::Protocol::Update'
-      {
-        :type     => 'Update',
-        :database => payload.full_collection_name,
-        :selector => sanitize(payload.selector),
-        :update   => sanitize(payload.update),
-        :flags    => payload.flags,
-      }
-    when 'Moped::Protocol::KillCursors'
-      {
-        :type                 => 'KillCursors',
-        :number_of_cursor_ids => payload.number_of_cursor_ids
-      }
-    else
-      {
-        :type     => payload.class.to_s.gsub('Moped::Protocol::', ''),
-        :database => payload.full_collection_name
-      }
-    end
-  end
-
-  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

data/lib/appsignal/integrations/padrino.rb

@@ -1,64 +0,0 @@
-require 'appsignal'
-
-module Appsignal::Integrations
-  module PadrinoPlugin
-    def self.init
-      Appsignal.logger.info("Loading Padrino (#{Padrino::VERSION}) integration")
-
-      root             = Padrino.mounted_root
-      Appsignal.config = Appsignal::Config.new(root, Padrino.env)
-
-      Appsignal.start_logger(File.join(root, 'log'))
-      Appsignal.start
-
-      if Appsignal.active?
-        Padrino.use(Appsignal::Rack::Listener)
-      end
-    end
-  end
-end
-
-module Padrino::Routing::InstanceMethods
-  alias route_without_appsignal route!
-
-  def route!(base = settings, pass_block = nil)
-    if env['sinatra.static_file']
-      route_without_appsignal(base, pass_block)
-    else
-      request_payload = {
-        :params  => request.params,
-        :session => request.session,
-        :method  => request.request_method,
-        :path    => request.path
-      }
-      ActiveSupport::Notifications.instrument('process_action.padrino', request_payload) do |request_payload|
-        begin
-          route_without_appsignal(base, pass_block)
-        rescue => e
-          Appsignal.add_exception(e); raise e
-        ensure
-          request_payload[:action] = get_payload_action(request)
-        end
-      end
-    end
-  end
-
-  def get_payload_action(request)
-    # Short-circut is there's no request object to obtain information from
-    return "#{settings.name}" if request.nil?
-
-    # Older versions of Padrino work with a route object
-    route_obj = defined?(request.route_obj) && request.route_obj
-    if route_obj && route_obj.respond_to?(:original_path)
-      return "#{settings.name}:#{request.route_obj.original_path}"
-    end
-
-    # Newer versions expose the action / controller on the request class
-    request_data = request.respond_to?(:action) ? request.action : request.fullpath
-    "#{settings.name}:#{request.controller}##{request_data}"
-  end
-end
-
-Padrino.after_load do
-  Appsignal::Integrations::PadrinoPlugin.init
-end

data/lib/appsignal/integrations/passenger.rb

@@ -1,13 +0,0 @@
-if defined?(::PhusionPassenger)
-  Appsignal.logger.info('Loading Passenger integration')
-
-  ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
-    Appsignal.logger.debug('starting worker process')
-    Appsignal.agent.forked!
-  end
-
-  ::PhusionPassenger.on_event(:stopping_worker_process) do
-    Appsignal.logger.debug('stopping worker process')
-    Appsignal.agent.shutdown(true, 'stopping Passenger worker process')
-  end
-end

data/lib/appsignal/integrations/rake.rb

@@ -1,29 +0,0 @@
-module Rake
-  class Task
-    alias_method :invoke_without_appsignal, :invoke
-
-    def invoke(*args)
-      invoke_with_appsignal(*args)
-    end
-
-    def invoke_with_appsignal(*args)
-      transaction = Appsignal::Transaction.create(
-        SecureRandom.uuid,
-        ENV,
-        :kind => 'background_job',
-        :action => name,
-        :params => args
-      )
-
-      invoke_without_appsignal(*args)
-    rescue => exception
-      unless Appsignal.is_ignored_exception?(exception)
-        transaction.add_exception(exception)
-      end
-      raise exception
-    ensure
-      transaction.complete!
-      Appsignal.agent.send_queue if Appsignal.active?
-    end
-  end
-end

data/lib/appsignal/integrations/unicorn.rb

@@ -1,25 +0,0 @@
-if defined?(::Unicorn)
-  Appsignal.logger.info('Loading Unicorn integration')
-
-  # We'd love to be able to hook this into Unicorn in a less
-  # intrusive way, but this is the best we can do given the
-  # options we have.
-
-  class Unicorn::HttpServer
-    alias_method :original_worker_loop, :worker_loop
-
-    def worker_loop(worker)
-      Appsignal.agent.forked!
-      original_worker_loop(worker)
-    end
-  end
-
-  class Unicorn::Worker
-    alias_method :original_close, :close
-
-    def close
-      Appsignal.agent.shutdown(true, 'stopping Unicorn worker process')
-      original_close
-    end
-  end
-end

data/lib/appsignal/ipc.rb

@@ -1,68 +0,0 @@
-require 'drb/drb'
-
-module Appsignal
-  class IPC
-    class << self
-      def forked!
-        Server.stop
-        Client.start
-        Appsignal.agent.stop_thread
-      end
-    end
-
-    class Server
-      class << self
-        attr_reader :uri
-
-        def start
-          local_tmp_path = File.join(Appsignal.config.root_path, 'tmp')
-          if File.exists?(local_tmp_path)
-            @uri = 'drbunix:' + File.join(local_tmp_path, "appsignal-#{Process.pid}")
-          else
-            @uri = "drbunix:/tmp/appsignal-#{Process.pid}"
-          end
-
-          Appsignal.logger.info("Starting IPC server, listening on #{uri}")
-          DRb.start_service(uri, Appsignal::IPC::Server)
-        end
-
-        def stop
-          Appsignal.logger.debug('Stopping IPC server')
-          DRb.stop_service
-        end
-
-        def enqueue(transaction)
-          Appsignal.logger.debug("Receiving transaction #{transaction.request_id} in IPC server")
-          Appsignal.enqueue(transaction)
-        end
-      end
-    end
-
-    class Client
-      class << self
-        attr_reader :server
-
-        def start
-          Appsignal.logger.debug('Starting IPC client')
-          @server = DRbObject.new_with_uri(Appsignal::IPC::Server.uri)
-          @active = true
-        end
-
-        def stop
-          Appsignal.logger.debug('Stopping IPC client')
-          @server = nil
-          @active = false
-        end
-
-        def enqueue(transaction)
-          Appsignal.logger.debug("Sending transaction #{transaction.request_id} in IPC client")
-          @server.enqueue(transaction)
-        end
-
-        def active?
-          !! @active
-        end
-      end
-    end
-  end
-end

data/lib/appsignal/transaction/formatter.rb

@@ -1,85 +0,0 @@
-require 'delegate'
-
-module Appsignal
-  class Transaction
-    class Formatter < SimpleDelegator
-      def hash
-        @hash ||= default_hash
-      end
-
-      def to_hash
-        merge_process_action_event_with_log_entry! if process_action_event
-        add_queue_duration_to_hash!
-        if exception?
-          add_exception_to_hash!
-          add_tags_to_hash!
-        end
-        add_events_to_hash! if slow_request?
-        hash
-      end
-
-      protected
-
-      def default_hash
-        {
-          :request_id => request_id,
-          :log_entry  => {
-            :path         => fullpath,
-            :kind         => kind,
-            :action       => action,
-            :time         => time,
-            :environment  => sanitized_environment,
-            :session_data => sanitized_session_data,
-            :params       => sanitized_params,
-            :revision     => Appsignal.agent.revision
-          },
-          :failed     => exception?
-        }
-      end
-
-      def merge_process_action_event_with_log_entry!
-        hash[:log_entry].merge!(event_to_hash(process_action_event))
-        hash[:log_entry].tap do |o|
-          o.merge!(o.delete(:payload))
-          o.delete(:controller)
-          o.delete(:action)
-          o.delete(:name)
-          o.delete(:class)
-          o.delete(:method)
-          o.delete(:queue_start)
-          o.delete(:params) unless Appsignal.config[:send_params]
-          o[:action] = action
-        end
-      end
-
-      def add_queue_duration_to_hash!
-        return unless queue_start && queue_start > 0
-        hash[:log_entry][:queue_duration] = 1000.0 * (hash[:log_entry][:time] - queue_start)
-      end
-
-      def add_tags_to_hash!
-        hash[:log_entry][:tags] = tags
-      end
-
-      def add_exception_to_hash!
-        hash[:exception] = exception
-      end
-
-      def add_events_to_hash!
-        hash[:events] = events.map do |event|
-          event_to_hash(event)
-        end
-      end
-
-      def event_to_hash(event)
-        {
-          :name => event.name,
-          :duration => event.duration,
-          :time => event.time.to_f,
-          :end => event.end.to_f,
-          :payload => event.payload
-        }
-      end
-    end
-  end
-end