appsignal 0.11.18 → 0.12.beta.0

data/lib/appsignal/event_formatter/net_http/request_formatter.rb

@@ -0,0 +1,13 @@
+module Appsignal
+  class EventFormatter
+    module NetHttp
+      class RequestFormatter < Appsignal::EventFormatter
+        register 'request.net_http'
+
+        def format(payload)
+          ["#{payload[:method]} #{payload[:protocol]}://#{payload[:domain]}", nil]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/instrumentations/net_http.rb

@@ -1,13 +1,15 @@
+require 'net/http'
+
 Net::HTTP.class_eval do
   alias request_without_appsignal request
 
   def request(request, body=nil, &block)
     ActiveSupport::Notifications.instrument(
       'request.net_http',
-      :host => request['host'] || self.address,
-      :scheme => use_ssl? ? 'https' : 'http',
-      :path => request.path,
-      :method => request.method
+      :protocol => use_ssl? ? 'https' : 'http',
+      :domain   => request['host'] || self.address,
+      :path     => request.path,
+      :method   => request.method
     ) do
       request_without_appsignal(request, body, &block)
     end

data/lib/appsignal/integrations/resque.rb

@@ -17,14 +17,6 @@ if defined?(::Resque)
     end
   end
 
-  # Set up IPC
-  Resque.before_first_fork do
-    Appsignal::IPC::Server.start if Appsignal.active?
-  end
-
-  # In the fork, stop the normal agent startup
-  # and stop listening to the server
-  Resque.after_fork do |job|
-    Appsignal::IPC.forked! if Appsignal.active?
-  end
+  # Extend the default job class with AppSignal instrumentation
+  Resque::Job.send(:extend, Appsignal::Integrations::ResquePlugin)
 end

data/lib/appsignal/integrations/sidekiq.rb

@@ -15,7 +15,7 @@ if defined?(::Sidekiq)
         def call(worker, item, queue)
           Appsignal.monitor_transaction(
             'perform_job.sidekiq',
-            :class       => item['wrapped'] || item['class'],
+            :class       => item['class'],
             :method      => 'perform',
             :metadata    => formatted_metadata(item),
             :params      => format_args(item['args']),
@@ -48,7 +48,7 @@ if defined?(::Sidekiq)
         end
 
         def truncate(text)
-          text.size > 200 ? "#{text[0...197]}..." : text
+          text.size > 100 ? "#{text[0...97]}..." : text
         end
       end
     end

data/lib/appsignal/integrations/sinatra.rb

@@ -1,4 +1,5 @@
 require 'appsignal'
+require 'appsignal/rack/sinatra_instrumentation'
 
 Appsignal.logger.info("Loading Sinatra (#{Sinatra::VERSION}) integration")
 

data/lib/appsignal/js_exception_transaction.rb

@@ -3,45 +3,61 @@ module Appsignal
 
     def initialize(data)
       @data = data
-      @time = Time.now.to_i
+      @uuid = SecureRandom.uuid
+
+      Appsignal::Extension.start_transaction(@uuid)
+
+      set_base_data
+      set_metadata
+      set_error
+      set_error_data
     end
 
-    def type
-      :exception
+    def set_base_data
+      Appsignal::Extension.set_transaction_basedata(
+        @uuid,
+        'frontend',
+        @data['action'],
+        0
+      )
     end
 
-    def action
-      @data['action']
+    def set_metadata
+      Appsignal::Extension.set_transaction_metadata(
+        @uuid, 'path', @data['path']
+      ) if @data['path']
     end
 
-    def clear_events!; end
-    def convert_values_to_primitives!; end
-    def events; []; end
+    def set_error
+      Appsignal::Extension.set_transaction_error(
+        @uuid,
+        @data['name'],
+        @data['message']
+      )
+    end
 
-    def to_hash
+    def set_error_data
       {
-        :request_id => SecureRandom.uuid,
-        :log_entry => {
-          :action      => action,
-          :path        => @data['path'],
-          :kind        => 'frontend',
-          :time        => @time,
-          :environment => @data['environment'],
-          :tags        => @data['tags'],
-          :revision    => Appsignal.agent.revision
-        },
-        :exception => {
-          :exception => @data['name'],
-          :message   => @data['message'],
-          :backtrace => @data['backtrace']
-        },
-        :failed => true
-      }
+        :params       => @data['params'],
+        :environment  => @data['environment'],
+        :backtrace    => @data['backtrace'],
+        :tags         => @data['tags']
+      }.each do |key, data|
+        next unless data.is_a?(Array) || data.is_a?(Hash)
+        begin
+          Appsignal::Extension.set_transaction_error_data(
+            @uuid,
+            key.to_s,
+            JSON.generate(data)
+          )
+        rescue JSON::GeneratorError=>e
+          Appsignal.logger.error("JSON generate error (#{e.message}) for '#{data.inspect}'")
+        end
+      end
     end
 
     def complete!
-      Appsignal.enqueue(self)
+      Appsignal::Extension.finish_transaction(@uuid)
     end
-
   end
 end

data/lib/appsignal/marker.rb

@@ -14,20 +14,18 @@ module Appsignal
     end
 
     def transmit
-      begin
-        transmitter = Transmitter.new(ACTION, config)
-        logger.info("Notifying Appsignal of deploy with: revision: #{marker_data[:revision]}, user: #{marker_data[:user]}")
-        result = transmitter.transmit(marker_data)
-        if result == '200'
-          logger.info('Appsignal has been notified of this deploy!')
-        else
-          raise "#{result} at #{transmitter.uri}"
-        end
-      rescue Exception => e
-        carefully_log_error(
-          "Something went wrong while trying to notify Appsignal: #{e}"
-        )
+      transmitter = Transmitter.new(ACTION, config)
+      logger.info("Notifying Appsignal of deploy with: revision: #{marker_data[:revision]}, user: #{marker_data[:user]}")
+      result = transmitter.transmit(marker_data)
+      if result == '200'
+        logger.info('Appsignal has been notified of this deploy!')
+      else
+        raise "#{result} at #{transmitter.uri}"
       end
+    rescue Exception => e
+      carefully_log_error(
+        "Something went wrong while trying to notify Appsignal: #{e}"
+      )
     end
   end
 end

data/lib/appsignal/params_sanitizer.rb

@@ -25,10 +25,8 @@ module Appsignal
           sanitize_hash(value)
         when Array
           sanitize_array(value)
-        when Fixnum, String, Symbol, Float
+        when Fixnum, String, Symbol
           unmodified(value)
-        when TrueClass, FalseClass
-          stringified(value)
         else
           inspected(value)
         end
@@ -48,16 +46,15 @@ module Appsignal
         target_array
       end
 
-      def stringified(value)
-        value.to_s
-      end
-
       def unmodified(value)
         value
       end
 
       def inspected(value)
-        "#<#{value.class.to_s}>"
+        value.inspect
+      rescue
+        # It turns out that sometimes inspect can fail
+        "#<#{value.class.to_s}/>"
       end
     end
   end

data/lib/appsignal/rack/instrumentation.rb

@@ -1,3 +1,5 @@
+require 'rack'
+
 module Appsignal
   module Rack
     class Instrumentation

data/lib/appsignal/rack/js_exception_catcher.rb

@@ -11,6 +11,7 @@ module Appsignal
           body        = JSON.parse(env['rack.input'].read)
           transaction = JSExceptionTransaction.new(body)
           transaction.complete!
+
           return [ 200, {}, []]
         else
           @app.call(env)

data/lib/appsignal/rack/listener.rb

@@ -18,7 +18,7 @@ module Appsignal
         Appsignal::Transaction.create(request_id(env), env)
         @app.call(env)
       rescue Exception => exception
-        Appsignal.add_exception(exception)
+        Appsignal.set_exception(exception)
         raise exception
       ensure
         Appsignal::Transaction.complete_current!

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -1,3 +1,5 @@
+require 'rack'
+
 module Appsignal
   module Rack
     class SinatraInstrumentation
@@ -7,14 +9,6 @@ module Appsignal
       end
 
       def call(env)
-        if Appsignal.active?
-          call_with_appsignal_monitoring(env)
-        else
-          @app.call(env)
-        end
-      end
-
-      def call_with_appsignal_monitoring(env)
         ActiveSupport::Notifications.instrument(
           'process_action.sinatra',
           raw_payload(env)
@@ -27,10 +21,6 @@ module Appsignal
             payload[:action] = env['sinatra.route']
           end
         end
-      ensure
-        # In production newer versions of Sinatra don't raise errors, but store
-        # them in the sinatra.error env var.
-        Appsignal.add_exception(env['sinatra.error']) if env['sinatra.error']
       end
 
       def raw_payload(env)

data/lib/appsignal/subscriber.rb

@@ -0,0 +1,59 @@
+module Appsignal
+  class Subscriber
+    PROCESS_ACTION_PREFIX = 'process_action'.freeze
+    PERFORM_JOB_PREFIX    = 'perform_job'.freeze
+    BLANK                 = ''.freeze
+
+    def initialize
+      subscribe
+    end
+
+    def subscribe
+      Appsignal.logger.debug('Subscribing to notifications')
+      # Subscribe to notifications that don't start with a !
+      ActiveSupport::Notifications.subscribe(/^[^!]/, self)
+    end
+
+    def unsubscribe
+      Appsignal.logger.debug('Unsubscribing from notifications')
+      ActiveSupport::Notifications.unsubscribe(self)
+    end
+
+    def resubscribe
+      Appsignal.logger.debug('Resubscribing to notifications')
+      unsubscribe
+      subscribe
+    end
+
+    def publish(name, *args)
+      # Not used, it's part of AS notifications but is not used in Rails
+      # and it seems to be unclear what it's function is. See:
+      # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/notifications/fanout.rb#L49
+    end
+
+    def start(name, id, payload)
+      return unless transaction = Appsignal::Transaction.current
+
+      return if transaction.paused?
+      Appsignal::Extension.start_event(transaction.request_id)
+    end
+
+    def finish(name, id, payload)
+      return unless transaction = Appsignal::Transaction.current
+
+      if name.start_with?(PROCESS_ACTION_PREFIX, PERFORM_JOB_PREFIX)
+        transaction.set_root_event(name, payload)
+      end
+
+      return if transaction.paused?
+
+      title, body = Appsignal::EventFormatter.format(name, payload)
+      Appsignal::Extension.finish_event(
+        transaction.request_id,
+        name,
+        title || BLANK,
+        body || BLANK
+      )
+    end
+  end
+end

data/lib/appsignal/transaction.rb

@@ -1,5 +1,8 @@
 module Appsignal
   class Transaction
+    HTTP_REQUEST   = 'http_request'.freeze
+    BACKGROUND_JOB = 'background_job'.freeze
+
     # Based on what Rails uses + some variables we'd like to show
     ENV_METHODS = %w(CONTENT_LENGTH AUTH_TYPE GATEWAY_INTERFACE
     PATH_TRANSLATED REMOTE_HOST REMOTE_IDENT REMOTE_USER REMOTE_ADDR
@@ -11,40 +14,39 @@ module Appsignal
     HTTP_CACHE_CONTROL HTTP_CONNECTION HTTP_USER_AGENT HTTP_FROM HTTP_NEGOTIATE
     HTTP_PRAGMA HTTP_REFERER HTTP_X_FORWARDED_FOR HTTP_CLIENT_IP).freeze
 
-    def self.create(request_id, env, defaults={})
-      Appsignal.logger.debug("Creating transaction: #{request_id}")
-      Thread.current[:appsignal_transaction_id] = request_id
-      Appsignal::Transaction.new(request_id, env, defaults)
-    end
+    class << self
+      def create(request_id, env)
+        Appsignal.logger.debug("Creating transaction: #{request_id}")
+        Appsignal::Extension.start_transaction(request_id)
+        Thread.current[:appsignal_transaction] = Appsignal::Transaction.new(request_id, env)
+      end
 
-    def self.current
-      Appsignal.transactions[Thread.current[:appsignal_transaction_id]]
-    end
+      def current
+        Thread.current[:appsignal_transaction]
+      end
 
-    def self.complete_current!
-      if current
-        current.complete!
-        Thread.current[:appsignal_transaction_id] = nil
-      else
-        Appsignal.logger.error('Trying to complete current, but no transaction present')
+      def complete_current!
+        if current
+          Appsignal::Extension.finish_transaction(current.request_id)
+          Thread.current[:appsignal_transaction] = nil
+        else
+          Appsignal.logger.error('Trying to complete current, but no transaction present')
+        end
       end
     end
 
-    attr_reader :request_id, :events, :process_action_event, :action, :exception,
-                :env, :fullpath, :time, :tags, :kind, :queue_start, :paused, :params
+    attr_reader :request_id, :process_action_event, :action, :exception,
+                :env, :fullpath, :time, :tags, :kind, :queue_start, :paused, :root_event_payload
 
-    def initialize(request_id, env, defaults={})
-      Appsignal.transactions[request_id] = self
-      @request_id           =  request_id
-      @events               = []
+    def initialize(request_id, env)
+      @root_event_payload = nil
+      @request_id = request_id
       @process_action_event = nil
-      @exception            = {}
-      @env                  = env
-      @params               = defaults[:params] || {}
-      @tags                 = defaults[:tags] || {}
-      @kind                 = defaults[:kind] || 'http_request'
-      @action               = defaults[:action]
-      @paused               = false
+      @exception = nil
+      @env = env
+      @tags = {}
+      @paused = false
+      @queue_start = -1
     end
 
     def sanitized_environment
@@ -55,148 +57,96 @@ module Appsignal
       @sanitized_session_data ||= {}
     end
 
-    def sanitized_params
-      @sanitized_params ||= {}
-    end
-
     def request
-      ::Rack::Request.new(@env) if @env
+      @request ||= ::Rack::Request.new(env)
     end
 
     def set_tags(given_tags={})
       @tags.merge!(given_tags)
     end
 
-    def pause!
-      @paused = true
-    end
-
-    def resume!
-      @paused = false
-    end
-
-    def set_process_action_event(event)
-      return unless event && event.payload
-      @process_action_event = event.dup
-      if @process_action_event.payload[:controller]
-        @action = "#{@process_action_event.payload[:controller]}##{@process_action_event.payload[:action]}"
-      else
-        @action = @process_action_event.payload[:action]
+    def set_root_event(name, payload)
+      @root_event_payload = payload
+      if name.start_with?(Subscriber::PROCESS_ACTION_PREFIX)
+        @action = "#{@root_event_payload[:controller]}##{@root_event_payload[:action]}"
+        @kind = HTTP_REQUEST
+        set_http_queue_start
+        set_metadata('path', payload[:path])
+        set_metadata('request_format', payload[:request_format])
+        set_metadata('request_method', payload[:request_method])
+        set_metadata('status', payload[:status].to_s)
+      elsif name.start_with?(Subscriber::PERFORM_JOB_PREFIX)
+        @action = "#{@root_event_payload[:class]}##{@root_event_payload[:method]}"
+        @kind = BACKGROUND_JOB
+        set_background_queue_start
       end
-      @kind = 'http_request'
-      set_http_queue_start
-    end
-
-    def set_perform_job_event(event)
-      return unless event && event.payload
-      @process_action_event = event.dup
-      @action = "#{@process_action_event.payload[:class]}##{@process_action_event.payload[:method]}"
-      @kind = 'background_job'
-      set_background_queue_start
-    end
-
-    def add_event(event)
-      @events << event unless @paused == true
-    end
-
-    def add_exception(ex=nil)
-      return unless ex
-      Appsignal.logger.debug("Adding #{ex.class.name} to transaction: #{request_id}")
-      @time      = Time.now.utc.to_f
-      @exception = {
-        :exception  => ex.class.name,
-        :message    => ex.message,
-        :backtrace  => clean_backtrace(ex)
-      }
-    end
-
-    def exception?
-      exception.any?
-    end
-
-    def clean_backtrace(exception)
-      return [] unless exception.backtrace.is_a?(Array)
-      if defined?(::Rails)
-        ::Rails.backtrace_cleaner.clean(exception.backtrace, nil)
-      else
-        exception.backtrace
+      Appsignal::Extension.set_transaction_basedata(
+        request_id,
+        kind,
+        action,
+        queue_start
+      )
+    end
+
+    def set_metadata(key, value)
+      return unless value
+      Appsignal::Extension.set_transaction_metadata(request_id, key, value)
+    end
+
+    def set_error(error)
+      return unless error
+      Appsignal::Extension.set_transaction_error(
+        request_id,
+        error.class.name,
+        error.message
+      )
+
+      {
+        :params       => sanitized_params,
+        :environment  => sanitized_environment,
+        :session_data => sanitized_session_data,
+        :backtrace    => cleaned_backtrace(error.backtrace),
+        :tags         => sanitized_tags
+      }.each do |key, data|
+        next unless data.is_a?(Array) || data.is_a?(Hash)
+        begin
+          Appsignal::Extension.set_transaction_error_data(
+            request_id,
+            key.to_s,
+            JSON.generate(data)
+          )
+        rescue JSON::GeneratorError=>e
+          Appsignal.logger.error("JSON generate error (#{e.message}) for '#{data.inspect}'")
+        end
       end
     end
+    alias_method :add_exception, :set_error
 
-    def slow_request?
-      return false unless process_action_event && process_action_event.payload
-      Appsignal.config[:slow_request_threshold] <= process_action_event.duration
-    end
-
-    def slower?(transaction)
-      process_action_event.duration > transaction.process_action_event.duration
-    end
-
-    def clear_events!
-      events.clear
-    end
-
-    def truncate!
-      return if truncated?
-      process_action_event.truncate!
-      events.clear
-      tags.clear
-      sanitized_environment.clear
-      sanitized_session_data.clear
-      sanitized_params.clear
-      @env = nil
-      @truncated = true
-    end
-
-    def truncated?
-      !! @truncated
-    end
-
-    def convert_values_to_primitives!
-      return if have_values_been_converted_to_primitives?
-      @process_action_event.sanitize! if @process_action_event
-      @events.each { |event| event.sanitize! }
-      add_sanitized_context!
-      @have_values_been_converted_to_primitives = true
-    end
-
-    def have_values_been_converted_to_primitives?
-      !! @have_values_been_converted_to_primitives
+    def pause!
+      @paused = true
     end
 
-    def type
-      return :exception if exception?
-      return :slow_request if slow_request?
-      :regular_request
+    def resume!
+      @paused = false
     end
 
-    def to_hash
-      Formatter.new(self).to_hash
+    def paused?
+      @paused == true
     end
 
-    def complete!
-      Thread.current[:appsignal_transaction_id] = nil
-      Appsignal.transactions.delete(@request_id)
-      if process_action_event || exception?
-        if Appsignal::IPC::Client.active?
-          convert_values_to_primitives!
-          Appsignal::IPC::Client.enqueue(self)
-        else
-          Appsignal.logger.debug("Enqueueing transaction: #{@request_id}")
-          Appsignal.enqueue(self)
-        end
-      else
-        Appsignal.logger.debug("Not processing transaction: #{@request_id} (#{events.length} events recorded)")
-      end
-    ensure
-      Appsignal.transactions.delete(@request_id)
-    end
+    protected
 
     def set_background_queue_start
-      queue_start = process_action_event.payload[:queue_start]
+      return unless root_event_payload
+      queue_start = root_event_payload[:queue_start]
       return unless queue_start
       Appsignal.logger.debug("Setting background queue start: #{queue_start}")
-      @queue_start = queue_start.to_f
+      @queue_start = (queue_start.to_f * 1000.0).to_i
+    end
+
+    def sanitized_params
+      return unless root_event_payload
+      Appsignal::ParamsSanitizer.sanitize(root_event_payload[:params])
     end
 
     def set_http_queue_start
@@ -208,52 +158,45 @@ module Appsignal
         unless cleaned_value.empty?
           value = cleaned_value.to_i
           [1_000_000.0, 1_000.0].each do |factor|
-            @queue_start = value / factor
+            @queue_start = (value / factor).to_i
             break if @queue_start > 946_681_200.0 # Ok if it's later than 2000
           end
         end
       end
     end
 
-    protected
+    def sanitized_environment
+      return unless env
+      {}.tap do |out|
+        ENV_METHODS.each do |key|
+          out[key] = env[key] if env[key]
+        end
+      end
+    end
 
-    def add_sanitized_context!
-      sanitize_environment!
-      sanitize_session_data! if kind == 'http_request'
-      sanitize_tags!
-      sanitize_params!
-      @env = nil
+    def sanitized_session_data
+      return if Appsignal.config[:skip_session_data] || !env
+      Appsignal::ParamsSanitizer.sanitize(request.session.to_hash)
     end
 
     # Only keep tags if they meet the following criteria:
     # * Key is a symbol or string with less then 100 chars
     # * Value is a symbol or string with less then 100 chars
     # * Value is an integer
-    def sanitize_tags!
-      @tags.keep_if do |k,v|
+    def sanitized_tags
+      @tags.select do |k, v|
         (k.is_a?(Symbol) || k.is_a?(String) && k.length <= 100) &&
         (((v.is_a?(Symbol) || v.is_a?(String)) && v.length <= 100) || (v.is_a?(Integer)))
       end
     end
 
-    def sanitize_environment!
-      return unless env && env.keys.any?
-      ENV_METHODS.each do |key|
-        sanitized_environment[key] = env[key]
+    def cleaned_backtrace(backtrace)
+      if defined?(::Rails)
+        ::Rails.backtrace_cleaner.clean(backtrace, nil)
+      else
+        backtrace
       end
     end
 
-    def sanitize_session_data!
-      return unless request
-      @sanitized_session_data = Appsignal::ParamsSanitizer.sanitize(
-        request.session.to_hash
-      ) if Appsignal.config[:skip_session_data] == false
-      @fullpath = request.fullpath
-    end
-
-    def sanitize_params!
-      return unless Appsignal.config[:send_params]
-      @sanitized_params = Appsignal::ParamsSanitizer.sanitize(@params)
-    end
   end
 end