appsignal 0.9.6 → 0.10.0.beta.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60fe669e8daa8b4015255cecaaa4f785b8fce679
-  data.tar.gz: f04514a5ba7022f74f1c7657a06ae584f968fa03
+  metadata.gz: eaaf7d6c75bf0cacbef11b40c1931a2cca2c9121
+  data.tar.gz: 1b7b1151ffbde430bc17267d93c7272a224c105d
 SHA512:
-  metadata.gz: 7b0c0d4c2557517439b529f95e9e71dec934ddd44a4f4b080516faad591efb5d4392816d2d839ac0a1309b236e21e51ad1552d6a1f56033440d8f912124d10dd
-  data.tar.gz: 72cb94912a40af82c53e166600d238f197b1c8373060e93e1100d0a6aabf55dc122f9495dd0c7f2dfc27be49d102162dd9e90955698008ef047e0b32a1377d9d
+  metadata.gz: 050ba5e12ac07e9f160e6be7711395f18424e4ba7a9ebb4a28cff887db5483d3762a9e70dc693d3bd7be8501663024f5e1f7e01fb67caf338976300d44acd95b
+  data.tar.gz: 05cd41d9e8f821244902433f910be5c42be51174f3d7e42572d84524beefee4e9e2a40bf85a28d876bbe338c89daa0a87e809d18b44a6e17abff406c3585c2b4

data/CHANGELOG.md

@@ -1,5 +1,12 @@
-# 0.9.6
-* Convert to primitives before sending through pipe
+# 0.10.0
+* Remove ActiveSupport dependency
+* Use vendored notifications if ActiveSupport is not present
+* Update bundled CA certificates
+* Fix issue where backtrace can be nil
+* Use Appsignal.monitor_transaction to instrument and log errors for
+  custom actions
+* Add option to ignore a specific action
+* Use a Mutex in agent instead of Thread.exclusive
 
 # 0.9.4
 * Log Rails and Sinatra version
@@ -59,7 +66,7 @@ Yanked
 * Alias tag_request to tag_job, for background jobs
 * Skip sanitization of env if env is nil
 * Small bugfix in forking logic
-* Don't send params if send_params is off in config
+* Don't send params if send_params is off in config 
 * Remove --repository option in CLI
 * Name option in appsignal notify_of_deploy CLI
 * Don't call to_hash on ENV

data/appsignal.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |gem|
   gem.version               = Appsignal::VERSION
   gem.required_ruby_version = '>= 1.9.3'
 
-  gem.add_dependency 'activesupport', '>= 3.0'
   gem.add_dependency 'rack'
   gem.add_dependency 'thread_safe'
 

data/lib/appsignal.rb

@@ -2,8 +2,12 @@ require 'logger'
 require 'rack'
 require 'thread_safe'
 require 'securerandom'
-require 'active_support/json'
-require 'active_support/notifications'
+
+begin
+  require 'active_support/notifications'
+rescue LoadError
+  require 'vendor/active_support/notifications'
+end
 
 module Appsignal
   class << self
@@ -69,6 +73,25 @@ module Appsignal
       agent.enqueue(transaction)
     end
 
+    def monitor_transaction(name, payload={})
+      unless active?
+        yield
+        return
+      end
+
+      begin
+        Appsignal::Transaction.create(SecureRandom.uuid, ENV)
+        ActiveSupport::Notifications.instrument(name, payload) do
+          yield
+        end
+      rescue Exception => exception
+        Appsignal.add_exception(exception)
+        raise exception
+      ensure
+        Appsignal::Transaction.complete_current!
+      end
+    end
+
     def listen_for_exception(&block)
       yield
     rescue Exception => exception
@@ -129,10 +152,6 @@ module Appsignal
       @logger << @in_memory_log.string if @in_memory_log
     end
 
-    def json
-      ActiveSupport::JSON
-    end
-
     def post_processing_middleware
       @post_processing_chain ||= Appsignal::Aggregator::PostProcessor.default_middleware
       yield @post_processing_chain if block_given?
@@ -147,6 +166,10 @@ module Appsignal
       Appsignal.config[:ignore_exceptions].include?(exception.class.name)
     end
 
+    def is_ignored_action?(action)
+      Appsignal.config[:ignore_actions].include?(action)
+    end
+
     # Convenience method for skipping instrumentations around a block of code.
     #
     # @since 0.8.7

data/lib/appsignal/agent.rb

@@ -2,8 +2,8 @@ module Appsignal
   class Agent
     ACTION = 'log_entries'.freeze
 
-    attr_accessor :aggregator, :thread, :master_pid, :pid, :active, :sleep_time,
-                  :transmitter, :subscriber, :paused
+    attr_accessor :aggregator, :mutex, :thread, :master_pid, :pid, :active,
+                  :sleep_time, :transmitter, :subscriber, :paused
 
     def initialize
       return unless Appsignal.active?
@@ -16,6 +16,7 @@ module Appsignal
       @pid = @master_pid
       @aggregator = Aggregator.new
       @transmitter = Transmitter.new(ACTION)
+      @mutex = Mutex.new
       subscribe
       start_thread
       Appsignal.logger.info('Started Appsignal agent')
@@ -81,6 +82,10 @@ module Appsignal
 
     def enqueue(transaction)
       forked! if @pid != Process.pid
+      if Appsignal.is_ignored_action?(transaction.action)
+        Appsignal.logger.debug("Ignoring transaction: #{transaction.request_id} (#{transaction.action})")
+        return
+      end
       aggregator.add(transaction)
     end
 
@@ -89,7 +94,7 @@ module Appsignal
       # Replace aggregator while making sure no thread
       # is adding to it's queue
       aggregator_to_be_sent = nil
-      Thread.exclusive do
+      mutex.synchronize do
         aggregator_to_be_sent = aggregator
         @aggregator = Aggregator.new
       end
@@ -108,7 +113,7 @@ module Appsignal
       Appsignal.logger.debug('Clearing queue')
       # Replace aggregator while making sure no thread
       # is adding to it's queue
-      Thread.exclusive do
+      mutex.synchronize do
         @aggregator = Aggregator.new
       end
     end
@@ -116,7 +121,7 @@ module Appsignal
     def forked!
       Appsignal.logger.info('Forked worker process')
       @pid = Process.pid
-      Thread.exclusive do
+      mutex.synchronize do
         @aggregator = Aggregator.new
       end
       resubscribe
@@ -126,7 +131,7 @@ module Appsignal
     def shutdown(send_current_queue=false, reason=nil)
       Appsignal.logger.info("Shutting down agent (#{reason})")
       unsubscribe
-      stop_thread
+      Thread.kill(thread) if thread
       send_queue if send_current_queue && @aggregator.has_transactions?
     end
 

data/lib/appsignal/cli.rb

@@ -110,7 +110,8 @@ module Appsignal
 
       def validate_required_options(required_options)
         missing = required_options.select do |required_option|
-          options[required_option].blank?
+          val = options[required_option]
+          val.nil? || (val.respond_to?(:empty?) && val.empty?)
         end
         if missing.any?
           puts "Missing options: #{missing.join(', ')}"

data/lib/appsignal/config.rb

@@ -8,6 +8,7 @@ module Appsignal
 
     DEFAULT_CONFIG = {
       :ignore_exceptions => [],
+      :ignore_actions => [],
       :send_params => true,
       :endpoint => 'https://push.appsignal.com/1',
       :slow_request_threshold => 200,

data/lib/appsignal/integrations/delayed_job.rb

@@ -11,25 +11,17 @@ if defined?(::Delayed::Plugin)
         end
 
         def self.invoke_with_instrumentation(job, block)
-          begin
-            Appsignal::Transaction.create(SecureRandom.uuid, ENV)
-            class_name, method_name = job.name.split('#')
-            ActiveSupport::Notifications.instrument(
-              'perform_job.delayed_job',
-              :class => class_name,
-              :method => method_name,
-              :priority => job.priority,
-              :attempts => job.attempts,
-              :queue => job.queue,
-              :queue_start => job.created_at
-            ) do
-              block.call(job)
-            end
-          rescue Exception => exception
-            Appsignal.add_exception(exception)
-            raise exception
-          ensure
-            Appsignal::Transaction.complete_current!
+          class_name, method_name = job.name.split('#')
+          Appsignal.monitor_transaction(
+            'perform_job.delayed_job',
+            :class => class_name,
+            :method => method_name,
+            :priority => job.priority,
+            :attempts => job.attempts,
+            :queue => job.queue,
+            :queue_start => job.created_at
+          ) do
+            block.call(job)
           end
         end
       end

data/lib/appsignal/integrations/resque.rb

@@ -4,23 +4,15 @@ if defined?(::Resque)
   module Appsignal
     module Integrations
       module ResquePlugin
-
         def around_perform_resque_plugin(*args)
-          Appsignal::Transaction.create(SecureRandom.uuid, ENV)
-          ActiveSupport::Notifications.instrument(
+          Appsignal.monitor_transaction(
             'perform_job.resque',
             :class => self.to_s,
             :method => 'perform'
           ) do
             yield
           end
-        rescue Exception => exception
-          Appsignal.add_exception(exception)
-          raise exception
-        ensure
-          Appsignal::Transaction.complete_current!
         end
-
       end
     end
   end

data/lib/appsignal/integrations/sidekiq.rb

@@ -5,8 +5,7 @@ if defined?(::Sidekiq)
     module Integrations
       class SidekiqPlugin
         def call(worker, item, queue)
-          Appsignal::Transaction.create(SecureRandom.uuid, ENV)
-          ActiveSupport::Notifications.instrument(
+          Appsignal.monitor_transaction(
             'perform_job.sidekiq',
             :class => item['class'],
             :method => 'perform',
@@ -16,11 +15,6 @@ if defined?(::Sidekiq)
           ) do
             yield
           end
-        rescue Exception => exception
-          Appsignal.add_exception(exception)
-          raise exception
-        ensure
-          Appsignal::Transaction.complete_current!
         end
       end
     end

data/lib/appsignal/transaction.rb

@@ -85,7 +85,7 @@
     end
 
     def exception?
-      !! exception
+      !!exception
     end
 
     def slow_request?
@@ -98,32 +98,20 @@
     end
 
     def truncate!
-      return if truncated?
       process_action_event.payload.clear
       events.clear
       tags.clear
       sanitized_environment.clear
       sanitized_session_data.clear
       @env = nil
-      @truncated = true
-    end
-
-    def truncated?
-      !! @truncated
     end
 
     def convert_values_to_primitives!
-      return if have_values_been_converted_to_primitives?
       Appsignal::Transaction::ParamsSanitizer.sanitize!(@process_action_event.payload) if @process_action_event
       @events.map do |o|
         Appsignal::Transaction::ParamsSanitizer.sanitize(o.payload)
       end
       add_sanitized_context!
-      @have_values_been_converted_to_primitives = true
-    end
-
-    def have_values_been_converted_to_primitives?
-      !! @have_values_been_converted_to_primitives
     end
 
     def type
@@ -141,7 +129,6 @@
       Appsignal.transactions.delete(@request_id)
       if process_action_event || exception?
         if Appsignal::Pipe.current
-          convert_values_to_primitives!
           Appsignal.logger.debug("Writing transaction to pipe: #{@request_id}")
           Appsignal::Pipe.current.write(self)
         else

data/lib/appsignal/transaction/formatter.rb

@@ -67,6 +67,7 @@ module Appsignal
       end
 
       def clean_backtrace(exception)
+        return [] unless exception.backtrace.is_a?(Array)
         if defined?(::Rails)
           ::Rails.backtrace_cleaner.clean(exception.backtrace, nil)
         else

data/lib/appsignal/transmitter.rb

@@ -2,6 +2,7 @@ require 'net/http'
 require 'net/https'
 require 'uri'
 require 'rack/utils'
+require 'json'
 
 module Appsignal
   class Transmitter
@@ -40,7 +41,7 @@ module Appsignal
         request['Content-Type'] = CONTENT_TYPE
         request['Content-Encoding'] = CONTENT_ENCODING
         request.body = Zlib::Deflate.deflate(
-          Appsignal.json.encode(payload),
+          JSON.generate(payload, :quirks_mode => true),
           Zlib::BEST_SPEED
         )
       end

data/lib/appsignal/version.rb

@@ -1,3 +1,3 @@
 module Appsignal
-  VERSION = '0.9.6'
+  VERSION = '0.10.0.beta.0'
 end

data/lib/generators/appsignal/templates/appsignal.yml

@@ -9,6 +9,10 @@ default: &defaults
   # The cuttoff point in ms above which a request is considered slow, default is 200
   # slow_request_threshold: 200
 
+  # Actions that should not be monitored by AppSignal
+  # ignore_actions:
+  #   - ApplicationController#isup
+
 # Configuration per environment, leave out an environment or set active
 # to false to not push metrics for that environment.
 <% environments.each do |environment| -%>

data/lib/vendor/active_support/notifications.rb

@@ -0,0 +1,212 @@
+require 'vendor/active_support/notifications/instrumenter'
+require 'vendor/active_support/notifications/fanout'
+require 'vendor/active_support/per_thread_registry'
+
+module ActiveSupport
+  # = Notifications
+  #
+  # <tt>ActiveSupport::Notifications</tt> provides an instrumentation API for
+  # Ruby.
+  #
+  # == Instrumenters
+  #
+  # To instrument an event you just need to do:
+  #
+  #   ActiveSupport::Notifications.instrument('render', extra: :information) do
+  #     render text: 'Foo'
+  #   end
+  #
+  # That executes the block first and notifies all subscribers once done.
+  #
+  # In the example above +render+ is the name of the event, and the rest is called
+  # the _payload_. The payload is a mechanism that allows instrumenters to pass
+  # extra information to subscribers. Payloads consist of a hash whose contents
+  # are arbitrary and generally depend on the event.
+  #
+  # == Subscribers
+  #
+  # You can consume those events and the information they provide by registering
+  # a subscriber.
+  #
+  #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
+  #     name    # => String, name of the event (such as 'render' from above)
+  #     start   # => Time, when the instrumented block started execution
+  #     finish  # => Time, when the instrumented block ended execution
+  #     id      # => String, unique ID for this notification
+  #     payload # => Hash, the payload
+  #   end
+  #
+  # For instance, let's store all "render" events in an array:
+  #
+  #   events = []
+  #
+  #   ActiveSupport::Notifications.subscribe('render') do |*args|
+  #     events << ActiveSupport::Notifications::Event.new(*args)
+  #   end
+  #
+  # That code returns right away, you are just subscribing to "render" events.
+  # The block is saved and will be called whenever someone instruments "render":
+  #
+  #   ActiveSupport::Notifications.instrument('render', extra: :information) do
+  #     render text: 'Foo'
+  #   end
+  #
+  #   event = events.first
+  #   event.name      # => "render"
+  #   event.duration  # => 10 (in milliseconds)
+  #   event.payload   # => { extra: :information }
+  #
+  # The block in the <tt>subscribe</tt> call gets the name of the event, start
+  # timestamp, end timestamp, a string with a unique identifier for that event
+  # (something like "535801666f04d0298cd6"), and a hash with the payload, in
+  # that order.
+  #
+  # If an exception happens during that particular instrumentation the payload will
+  # have a key <tt>:exception</tt> with an array of two elements as value: a string with
+  # the name of the exception class, and the exception message.
+  #
+  # As the previous example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
+  # is able to take the arguments as they come and provide an object-oriented
+  # interface to that data.
+  #
+  # It is also possible to pass an object as the second parameter passed to the
+  # <tt>subscribe</tt> method instead of a block:
+  #
+  #   module ActionController
+  #     class PageRequest
+  #       def call(name, started, finished, unique_id, payload)
+  #         Rails.logger.debug ['notification:', name, started, finished, unique_id, payload].join(' ')
+  #       end
+  #     end
+  #   end
+  #
+  #   ActiveSupport::Notifications.subscribe('process_action.action_controller', ActionController::PageRequest.new)
+  #
+  # resulting in the following output within the logs including a hash with the payload:
+  #
+  #   notification: process_action.action_controller 2012-04-13 01:08:35 +0300 2012-04-13 01:08:35 +0300 af358ed7fab884532ec7 {
+  #      controller: "Devise::SessionsController",
+  #      action: "new",
+  #      params: {"action"=>"new", "controller"=>"devise/sessions"},
+  #      format: :html,
+  #      method: "GET",
+  #      path: "/login/sign_in",
+  #      status: 200,
+  #      view_runtime: 279.3080806732178,
+  #      db_runtime: 40.053
+  #    }
+  #
+  # You can also subscribe to all events whose name matches a certain regexp:
+  #
+  #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
+  #     ...
+  #   end
+  #
+  # and even pass no argument to <tt>subscribe</tt>, in which case you are subscribing
+  # to all events.
+  #
+  # == Temporary Subscriptions
+  #
+  # Sometimes you do not want to subscribe to an event for the entire life of
+  # the application. There are two ways to unsubscribe.
+  #
+  # WARNING: The instrumentation framework is designed for long-running subscribers,
+  # use this feature sparingly because it wipes some internal caches and that has
+  # a negative impact on performance.
+  #
+  # === Subscribe While a Block Runs
+  #
+  # You can subscribe to some event temporarily while some block runs. For
+  # example, in
+  #
+  #   callback = lambda {|*args| ... }
+  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
+  #     ...
+  #   end
+  #
+  # the callback will be called for all "sql.active_record" events instrumented
+  # during the execution of the block. The callback is unsubscribed automatically
+  # after that.
+  #
+  # === Manual Unsubscription
+  #
+  # The +subscribe+ method returns a subscriber object:
+  #
+  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |*args|
+  #     ...
+  #   end
+  #
+  # To prevent that block from being called anymore, just unsubscribe passing
+  # that reference:
+  #
+  #   ActiveSupport::Notifications.unsubscribe(subscriber)
+  #
+  # You can also unsubscribe by passing the name of the subscriber object. Note
+  # that this will unsubscribe all subscriptions with the given name:
+  #
+  #   ActiveSupport::Notifications.unsubscribe("render")
+  #
+  # == Default Queue
+  #
+  # Notifications ships with a queue implementation that consumes and publishes events
+  # to all log subscribers. You can use any queue implementation you want.
+  #
+  module Notifications
+    class << self
+      attr_accessor :notifier
+
+      def publish(name, *args)
+        notifier.publish(name, *args)
+      end
+
+      def instrument(name, payload = {})
+        if notifier.listening?(name)
+          instrumenter.instrument(name, payload) { yield payload if block_given? }
+        else
+          yield payload if block_given?
+        end
+      end
+
+      def subscribe(*args, &block)
+        notifier.subscribe(*args, &block)
+      end
+
+      def subscribed(callback, *args, &block)
+        subscriber = subscribe(*args, &callback)
+        yield
+      ensure
+        unsubscribe(subscriber)
+      end
+
+      def unsubscribe(subscriber_or_name)
+        notifier.unsubscribe(subscriber_or_name)
+      end
+
+      def instrumenter
+        InstrumentationRegistry.instance.instrumenter_for(notifier)
+      end
+    end
+
+    # This class is a registry which holds all of the +Instrumenter+ objects
+    # in a particular thread local. To access the +Instrumenter+ object for a
+    # particular +notifier+, you can call the following method:
+    #
+    #   InstrumentationRegistry.instrumenter_for(notifier)
+    #
+    # The instrumenters for multiple notifiers are held in a single instance of
+    # this class.
+    class InstrumentationRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      def initialize
+        @registry = {}
+      end
+
+      def instrumenter_for(notifier)
+        @registry[notifier] ||= Instrumenter.new(notifier)
+      end
+    end
+
+    self.notifier = Fanout.new
+  end
+end