appsignal 1.4.0.alpha.2 → 1.4.0.beta.1

data/circle.yml

@@ -1,12 +0,0 @@
-machine:
-  ruby:
-    version: 2.3.0
-
-dependencies:
-  override:
-    - bundle
-    - bundle exec rake generate_bundle_and_spec_all
-
-test:
-  override:
-    - ./bundle_and_spec_all_rvm

data/lib/appsignal/subscriber.rb

@@ -1,55 +0,0 @@
-module Appsignal
-  class Subscriber
-    attr_reader :as_subscriber
-
-    def initialize
-      subscribe
-    end
-
-    def subscribe
-      Appsignal.logger.debug('Subscribing to notifications')
-      # Subscribe to notifications that don't start with a !
-      @as_subscriber = ActiveSupport::Notifications.subscribe(/^[^!]/, self)
-    end
-
-    def unsubscribe
-      if @as_subscriber
-        Appsignal.logger.debug('Unsubscribing from notifications')
-        ActiveSupport::Notifications.unsubscribe(@as_subscriber)
-        @as_subscriber = nil
-      end
-    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.nil_transaction? || transaction.paused?
-
-      transaction.start_event
-    end
-
-    def finish(name, id, payload)
-      return unless transaction = Appsignal::Transaction.current
-      return if transaction.nil_transaction? || transaction.paused?
-
-      title, body, body_format = Appsignal::EventFormatter.format(name, payload)
-      transaction.finish_event(
-        name,
-        title,
-        body,
-        body_format
-      )
-    end
-  end
-end

data/lib/appsignal/update_active_support.rb

@@ -1,20 +0,0 @@
-module Appsignal
-  module UpdateActiveSupport
-    def self.run
-      # Get the old subscribers if present
-      old_notifier = ActiveSupport::Notifications.notifier
-      subscribers  = old_notifier.instance_variable_get('@subscribers') || []
-
-      # Require the newer notifications
-      require 'vendor/active_support/notifications'
-
-      # Re-subscribe the old subscribers
-      subscribers.each do |sub|
-        pattern  = sub.instance_variable_get('@pattern')
-        delegate = sub.instance_variable_get('@delegate')
-        next unless pattern && delegate
-        ActiveSupport::Notifications.subscribe(pattern, delegate)
-      end
-    end
-  end
-end

data/lib/vendor/active_support/notifications.rb

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

data/lib/vendor/active_support/notifications/fanout.rb

@@ -1,157 +0,0 @@
-require 'mutex_m'
-require 'thread_safe'
-
-module ActiveSupport
-  module Notifications
-    # This is a default queue implementation that ships with Notifications.
-    # It just pushes events to all registered log subscribers.
-    #
-    # This class is thread safe. All methods are reentrant.
-    class Fanout
-      include Mutex_m
-
-      def initialize
-        @subscribers = []
-        @listeners_for = ThreadSafe::Cache.new
-        super
-      end
-
-      def subscribe(pattern = nil, block = Proc.new)
-        subscriber = Subscribers.new pattern, block
-        synchronize do
-          @subscribers << subscriber
-          @listeners_for.clear
-        end
-        subscriber
-      end
-
-      def unsubscribe(subscriber_or_name)
-        synchronize do
-          case subscriber_or_name
-          when String
-            @subscribers.reject! { |s| s.matches?(subscriber_or_name) }
-          else
-            @subscribers.delete(subscriber_or_name)
-          end
-
-          @listeners_for.clear
-        end
-      end
-
-      def start(name, id, payload)
-        listeners_for(name).each { |s| s.start(name, id, payload) }
-      end
-
-      def finish(name, id, payload)
-        listeners_for(name).each { |s| s.finish(name, id, payload) }
-      end
-
-      def publish(name, *args)
-        listeners_for(name).each { |s| s.publish(name, *args) }
-      end
-
-      def listeners_for(name)
-        # this is correctly done double-checked locking (ThreadSafe::Cache's lookups have volatile semantics)
-        @listeners_for[name] || synchronize do
-          # use synchronisation when accessing @subscribers
-          @listeners_for[name] ||= @subscribers.select { |s| s.subscribed_to?(name) }
-        end
-      end
-
-      def listening?(name)
-        listeners_for(name).any?
-      end
-
-      # This is a sync queue, so there is no waiting.
-      def wait
-      end
-
-      module Subscribers # :nodoc:
-        def self.new(pattern, listener)
-          if listener.respond_to?(:start) and listener.respond_to?(:finish)
-            subscriber = Evented.new pattern, listener
-          else
-            subscriber = Timed.new pattern, listener
-          end
-
-          unless pattern
-            AllMessages.new(subscriber)
-          else
-            subscriber
-          end
-        end
-
-        class Evented #:nodoc:
-          def initialize(pattern, delegate)
-            @pattern = pattern
-            @delegate = delegate
-            @can_publish = delegate.respond_to?(:publish)
-          end
-
-          def publish(name, *args)
-            if @can_publish
-              @delegate.publish name, *args
-            end
-          end
-
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
-          end
-
-          def subscribed_to?(name)
-            @pattern === name
-          end
-
-          def matches?(name)
-            @pattern && @pattern === name
-          end
-        end
-
-        class Timed < Evented
-          def publish(name, *args)
-            @delegate.call name, *args
-          end
-
-          def start(name, id, payload)
-            timestack = Thread.current[:_timestack] ||= []
-            timestack.push Time.now
-          end
-
-          def finish(name, id, payload)
-            timestack = Thread.current[:_timestack]
-            started = timestack.pop
-            @delegate.call(name, started, Time.now, id, payload)
-          end
-        end
-
-        class AllMessages # :nodoc:
-          def initialize(delegate)
-            @delegate = delegate
-          end
-
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
-          end
-
-          def publish(name, *args)
-            @delegate.publish name, *args
-          end
-
-          def subscribed_to?(name)
-            true
-          end
-
-          alias :matches? :===
-        end
-      end
-    end
-  end
-end