appsignal 0.10.6 → 0.11.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29ac953458214ed9268bd6d52afd40b5c45785cd
-  data.tar.gz: 858cfc04cd727f92934d36c6d1dbcda240404d85
+  metadata.gz: d94bbce0b6f553797da38925a40704be00398b01
+  data.tar.gz: 27e0ba9502c0f57b5842980dcfd9d72f66a4ae78
 SHA512:
-  metadata.gz: 8e70b79af43d968f5b18e5d526ffc79a4f31e1e7f147f828b47cd011dbcb4455b9ca3eeadfb9262628e1bc4be3a83cbd550a48c20f5ee245eea7dec264ab6132
-  data.tar.gz: 8e453b41199aef1fa956a701b3d8a929c36d6d9222e5f216106e929e15e76510b66d6be543943796c652ab6235b1aa27006216717ca32bccad548e493fffbc0c
+  metadata.gz: aca7235ba46c21dfe16effded54ca808aea9f3faa7e87359374e1caac5ea8570ceb16f8b36454ab42b91a6c6e8eec54bf05471b2ee71ac8462071c6b1ac0eb93
+  data.tar.gz: ffc98ceed5e8343981fa11237a9c9a12350d66d7973b9aa16774c53d5f9a43f166c69bf3152187e4f62b8d7a294954227a5f9d5dc74431c472a0af36dfc880b6

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.11.0
+* Improved inter process communication
+* Retry sending data when the push api is not reachable
+* Our own event handling to allow for more flexibility and reliability
+  when using a threaded environment
+
 # 0.10.6
 * Add config option to skip session data
 

data/lib/appsignal.rb

@@ -184,6 +184,7 @@ module Appsignal
 end
 
 require 'appsignal/agent'
+require 'appsignal/event'
 require 'appsignal/aggregator'
 require 'appsignal/aggregator/post_processor'
 require 'appsignal/aggregator/middleware'
@@ -192,10 +193,11 @@ require 'appsignal/config'
 require 'appsignal/marker'
 require 'appsignal/rack/listener'
 require 'appsignal/rack/instrumentation'
+require 'appsignal/params_sanitizer'
 require 'appsignal/transaction'
 require 'appsignal/transaction/formatter'
 require 'appsignal/transaction/params_sanitizer'
 require 'appsignal/transmitter'
-require 'appsignal/pipe'
+require 'appsignal/ipc'
 require 'appsignal/version'
 require 'appsignal/integrations/rails'

data/lib/appsignal/agent.rb

@@ -1,9 +1,10 @@
 module Appsignal
   class Agent
     ACTION = 'log_entries'.freeze
+    AGGREGATOR_LIMIT = 5 # Five minutes with a sleep time of 60 seconds
 
     attr_accessor :aggregator, :thread, :master_pid, :pid, :active, :sleep_time,
-                  :transmitter, :subscriber, :paused
+                  :transmitter, :subscriber, :paused, :aggregator_queue
 
     def initialize
       return unless Appsignal.config.active?
@@ -12,10 +13,12 @@ module Appsignal
       else
         @sleep_time = 60.0
       end
-      @master_pid = Process.pid
-      @pid = @master_pid
-      @aggregator = Aggregator.new
-      @transmitter = Transmitter.new(ACTION)
+      @master_pid       = Process.pid
+      @pid              = @master_pid
+      @aggregator       = Aggregator.new
+      @transmitter      = Transmitter.new(ACTION)
+      @aggregator_queue = []
+
       subscribe
       start_thread
       @active = true
@@ -33,6 +36,7 @@ module Appsignal
           sleep(rand(sleep_time))
           loop do
             send_queue if aggregator.has_transactions?
+            truncate_aggregator_queue
             Appsignal.logger.debug("Sleeping #{sleep_time}")
             sleep(sleep_time)
           end
@@ -61,7 +65,7 @@ module Appsignal
       # Subscribe to notifications that don't start with a !
       @subscriber = ActiveSupport::Notifications.subscribe(/^[^!]/) do |*args|
         if Appsignal::Transaction.current
-          event = ActiveSupport::Notifications::Event.new(*args)
+          event = Appsignal::Event.event_for_instrumentation(*args)
           if event.name.start_with?('process_action')
             Appsignal::Transaction.current.set_process_action_event(event)
           elsif event.name.start_with?('perform_job')
@@ -104,18 +108,38 @@ module Appsignal
       end
 
       begin
-        return unless aggregator_to_be_sent.has_transactions?
-        handle_result(
-          transmitter.transmit(aggregator_to_be_sent.post_processed_queue!)
-        )
-      rescue OpenSSL::SSL::SSLError => ex
-        Appsignal.logger.error "OpenSSL::SSL::SSLError: #{ex.message}"
+        add_to_aggregator_queue(aggregator_to_be_sent.post_processed_queue!)
+        send_aggregators
       rescue Exception => ex
         Appsignal.logger.error "#{ex.class} while sending queue: #{ex.message}"
         Appsignal.logger.error ex.backtrace.join('\n')
       end
     end
 
+    def add_to_aggregator_queue(aggregator)
+      @aggregator_queue.unshift(aggregator)
+    end
+
+    def send_aggregators
+      @aggregator_queue.map! do |payload|
+        begin
+          if handle_result(transmitter.transmit(payload))
+            nil
+          else
+            payload
+          end
+        rescue *Transmitter::HTTP_ERRORS
+          payload
+        end
+      end.compact!
+    end
+
+    def truncate_aggregator_queue(limit = AGGREGATOR_LIMIT)
+      return unless @aggregator_queue.length > limit
+      Appsignal.logger.error "Aggregator queue to large, removing items"
+      @aggregator_queue = @aggregator_queue.first(limit)
+    end
+
     def clear_queue
       Appsignal.logger.debug('Clearing queue')
       # Replace aggregator while making sure no thread
@@ -150,27 +174,34 @@ module Appsignal
       Appsignal.logger.debug "Queue sent, response code: #{code}"
       case code.to_i
       when 200 # ok
+        true
       when 420 # Enhance Your Calm
         Appsignal.logger.info 'Increasing sleep time since the server told us to'
         @sleep_time = sleep_time * 1.5
+        true
       when 413 # Request Entity Too Large
         Appsignal.logger.info 'Decreasing sleep time since our last push was too large'
         @sleep_time = sleep_time / 1.5
+        true
       when 429
         Appsignal.logger.error 'Too many requests sent'
         shutdown(false, 429)
+        true
       when 406
         Appsignal.logger.error 'Your appsignal gem cannot communicate with the API anymore, please upgrade.'
         shutdown(false, 406)
+        true
       when 402
         Appsignal.logger.error 'Payment required'
         shutdown(false, 402)
+        true
       when 401
         Appsignal.logger.error 'API token cannot be authorized'
         shutdown(false, 401)
+        true
       else
         Appsignal.logger.error "Unknown Appsignal response code: '#{code}'"
-        clear_queue
+        false
       end
     end
   end

data/lib/appsignal/aggregator.rb

@@ -19,6 +19,7 @@ module Appsignal
       when :slow_request
         pre_process_slowness!(transaction)
       when :exception
+        transaction.clear_events!
         transaction.convert_values_to_primitives!
       end
       counts[transaction.type] += 1

data/lib/appsignal/event.rb

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,85 @@
+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,
+      }
+    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/resque.rb

@@ -17,16 +17,15 @@ if defined?(::Resque)
     end
   end
 
-  # Create a pipe for the workers to write to
+  # Set up IPC
   Resque.before_first_fork do
-    Appsignal::Pipe.init
+    Appsignal::IPC::Server.start
   end
 
   # In the fork, stop the normal agent startup
-  # and stop listening to the pipe (we'll only use it for writing)
+  # and stop listening to the server
   Resque.after_fork do |job|
-    Appsignal.agent.stop_thread
-    Appsignal::Pipe.current.stop_listening!
+    Appsignal::IPC.forked!
   end
 
   # Extend the default job class with AppSignal instrumentation

data/lib/appsignal/ipc.rb

@@ -0,0 +1,68 @@
+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/params_sanitizer.rb

@@ -0,0 +1,117 @@
+module Appsignal
+  class ParamsSanitizer
+    class << self
+      def sanitize(params)
+        ParamsSanitizerCopy.sanitize_value(params)
+      end
+
+      def sanitize!(params)
+        ParamsSanitizerDestructive.sanitize_value(params)
+      end
+
+      def scrub(params)
+        ParamsSanitizerCopyScrub.sanitize_value(params)
+      end
+
+      def scrub!(params)
+        ParamsSanitizerDestructiveScrub.sanitize_value(params)
+      end
+
+      protected
+
+      def sanitize_value(value)
+        case value
+        when Hash
+          sanitize_hash(value)
+        when Array
+          sanitize_array(value)
+        when Fixnum, String, Symbol
+          unmodified(value)
+        else
+          inspected(value)
+        end
+      end
+
+      def sanitize_hash_with_target(source_hash, target_hash)
+        source_hash.each_pair do |key, value|
+          target_hash[key] = sanitize_value(value)
+        end
+        target_hash
+      end
+
+      def sanitize_array_with_target(source_array, target_array)
+        source_array.each_with_index do |item, index|
+          target_array[index] = sanitize_value(item)
+        end
+        target_array
+      end
+
+      def unmodified(value)
+        value
+      end
+
+      def inspected(value)
+        value.inspect
+      rescue
+        # It turns out that sometimes inspect can fail
+        "#<#{value.class.to_s}/>"
+      end
+    end
+  end
+
+  class ParamsSanitizerCopy < ParamsSanitizer
+    class << self
+      protected
+
+      def sanitize_hash(hash)
+        sanitize_hash_with_target(hash, {})
+      end
+
+      def sanitize_array(array)
+        sanitize_array_with_target(array, [])
+      end
+    end
+  end
+
+  class ParamsSanitizerDestructive < ParamsSanitizer
+    class << self
+      protected
+
+      def sanitize_hash(hash)
+        sanitize_hash_with_target(hash, hash)
+      end
+
+      def sanitize_array(array)
+        sanitize_array_with_target(array, array)
+      end
+    end
+  end
+
+  class ParamsSanitizerCopyScrub < ParamsSanitizerCopy
+    class << self
+      protected
+
+      def unmodified(value)
+        '?'
+      end
+
+      def inspected(value)
+        '?'
+      end
+    end
+  end
+
+  class ParamsSanitizerDestructiveScrub < ParamsSanitizerDestructive
+    class << self
+      protected
+
+      def unmodified(value)
+        '?'
+      end
+
+      def inspected(value)
+        '?'
+      end
+    end
+  end
+end