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

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

@@ -1,73 +0,0 @@
-require 'securerandom'
-
-module ActiveSupport
-  module Notifications
-    # Instrumenters are stored in a thread local.
-    class Instrumenter
-      attr_reader :id
-
-      def initialize(notifier)
-        @id       = unique_id
-        @notifier = notifier
-      end
-
-      # Instrument the given block by measuring the time taken to execute it
-      # and publish it. Notice that events get sent even if an error occurs
-      # in the passed-in block.
-      def instrument(name, payload={})
-        start name, payload
-        begin
-          yield payload
-        rescue Exception => e
-          payload[:exception] = [e.class.name, e.message]
-          raise e
-        ensure
-          finish name, payload
-        end
-      end
-
-      # Send a start notification with +name+ and +payload+.
-      def start(name, payload)
-        @notifier.start name, @id, payload
-      end
-
-      # Send a finish notification with +name+ and +payload+.
-      def finish(name, payload)
-        @notifier.finish name, @id, payload
-      end
-
-      private
-
-      def unique_id
-        SecureRandom.hex(10)
-      end
-    end
-
-    class Event
-      attr_reader :name, :time, :transaction_id, :payload, :children
-      attr_accessor :end
-
-      def initialize(name, start, ending, transaction_id, payload)
-        @name           = name
-        @payload        = payload.dup
-        @time           = start
-        @transaction_id = transaction_id
-        @end            = ending
-        @children       = []
-        @duration       = nil
-      end
-
-      def duration
-        @duration ||= 1000.0 * (self.end - time)
-      end
-
-      def <<(event)
-        @children << event
-      end
-
-      def parent_of?(event)
-        @children.include? event
-      end
-    end
-  end
-end

data/lib/vendor/active_support/per_thread_registry.rb

@@ -1,53 +0,0 @@
-module ActiveSupport
-  # This module is used to encapsulate access to thread local variables.
-  #
-  # Instead of polluting the thread locals namespace:
-  #
-  #   Thread.current[:connection_handler]
-  #
-  # you define a class that extends this module:
-  #
-  #   module ActiveRecord
-  #     class RuntimeRegistry
-  #       extend ActiveSupport::PerThreadRegistry
-  #
-  #       attr_accessor :connection_handler
-  #     end
-  #   end
-  #
-  # and invoke the declared instance accessors as class methods. So
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
-  #
-  # sets a connection handler local to the current thread, and
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler
-  #
-  # returns a connection handler local to the current thread.
-  #
-  # This feature is accomplished by instantiating the class and storing the
-  # instance as a thread local keyed by the class name. In the example above
-  # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
-  # The class methods proxy to said thread local instance.
-  #
-  # If the class has an initializer, it must accept no arguments.
-  module PerThreadRegistry
-    def self.extended(object)
-      object.instance_variable_set '@per_thread_registry_key', object.name.freeze
-    end
-
-    def instance
-      Thread.current[@per_thread_registry_key] ||= new
-    end
-
-    protected
-      def method_missing(name, *args, &block) # :nodoc:
-        # Caches the method definition as a singleton method of the receiver.
-        define_singleton_method(name) do |*a, &b|
-          instance.public_send(name, *a, &b)
-        end
-
-        send(name, *args, &block)
-      end
-  end
-end

data/spec/lib/appsignal/subscriber_spec.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-
-describe Appsignal::Subscriber do
-  before :all do
-    start_agent
-  end
-
-  before do
-    ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers).clear
-    Thread.current[:appsignal_transaction] = nil
-  end
-
-  let(:subscriber) { Appsignal::Subscriber.new }
-  subject { subscriber }
-
-  context "initialization" do
-    before do
-      subject
-    end
-
-    it "should be in the subscriber list" do
-      ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers).select do |s|
-        s.instance_variable_get(:@delegate).is_a?(Appsignal::Subscriber)
-      end.count.should eq 1
-    end
-  end
-
-  context "subscriptions" do
-    describe "subscribe" do
-      it "should subscribe" do
-        subject.subscribe
-        subject.as_subscriber.should_not be_nil
-
-        ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers).select do |s|
-          s.instance_variable_get(:@delegate).is_a?(Appsignal::Subscriber)
-        end.count.should eq 2
-      end
-    end
-
-    describe "#unsubscribe" do
-      it "should unsubscribe" do
-        subject.unsubscribe
-        subject.as_subscriber.should be_nil
-
-        ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers).select do |s|
-          s.instance_variable_get(:@delegate).is_a?(Appsignal::Subscriber)
-        end.count.should eq 0
-      end
-    end
-
-    describe "#resubscribe" do
-      it "should unsubscribe and subscribe" do
-        subject.resubscribe
-        subject.as_subscriber.should_not be_nil
-
-        ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers).select do |s|
-          s.instance_variable_get(:@delegate).is_a?(Appsignal::Subscriber)
-        end.count.should eq 1
-      end
-    end
-  end
-
-  describe "#publish" do
-    it "should exist" do
-      lambda {
-        subject.publish('name', '')
-      }.should_not raise_error
-    end
-  end
-
-  context "handling events using #start and #finish" do
-    before do
-      subscriber
-    end
-
-    it "should should not listen to events that start with a bang" do
-      subject.should_not_receive(:start)
-      subject.should_not_receive(:finish)
-
-      ActiveSupport::Notifications.instrument '!render_template'
-    end
-
-    it "should not record events when there is no current transaction" do
-      Appsignal::Extension.should_not_receive(:start_event)
-      Appsignal::Extension.should_not_receive(:finish_event)
-
-      lambda {
-        ActiveSupport::Notifications.instrument 'something'
-      }.should_not raise_error
-    end
-
-    context "with a current transaction" do
-      let(:transaction) { Appsignal::Transaction.current }
-
-      before do
-        Appsignal::Transaction.create('request-id', Appsignal::Transaction::HTTP_REQUEST, {})
-      end
-
-      it "should call native start and finish event for every event" do
-        transaction.should_receive(:start_event).exactly(4).times
-        transaction.should_receive(:finish_event).with('one', nil, nil, nil).once
-        transaction.should_receive(:finish_event).with('two', nil, nil, nil).once
-        transaction.should_receive(:finish_event).with('two.three', nil, nil, nil).once
-        transaction.should_receive(:finish_event).with('one.three', nil, nil, nil).once
-
-        ActiveSupport::Notifications.instrument('one') do
-          ActiveSupport::Notifications.instrument('two') do
-            ActiveSupport::Notifications.instrument('one.three') do
-            end
-            ActiveSupport::Notifications.instrument('two.three') do
-            end
-          end
-        end
-      end
-
-      it "should call finish with title and body if there is a formatter" do
-        transaction.should_receive(:start_event).once
-        transaction.should_receive(:finish_event).with(
-          'request.faraday',
-          'GET http://www.google.com',
-          'GET http://www.google.com',
-          nil
-        ).once
-
-        ActiveSupport::Notifications.instrument(
-          'request.faraday',
-          :method => 'get',
-          :url => URI('http://www.google.com')
-        )
-      end
-
-      it "should call finish with title, body and body format if there is a formatter that returns it" do
-        transaction.should_receive(:start_event).once
-        transaction.should_receive(:finish_event).with(
-          'sql.active_record',
-          'Something load',
-          'SELECT * FROM something',
-          1
-        ).once
-
-        ActiveSupport::Notifications.instrument(
-          'sql.active_record',
-          :name => 'Something load',
-          :sql  => 'SELECT * FROM something'
-        )
-      end
-
-      context "when paused" do
-        before { transaction.pause! }
-
-        it "should add no events" do
-          Appsignal::Extension.should_not_receive(:start_event)
-          Appsignal::Extension.should_not_receive(:finish_event)
-
-          ActiveSupport::Notifications.instrument 'sql.active_record'
-        end
-      end
-    end
-  end
-end

data/spec/lib/appsignal/update_active_support_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe 'Appsignal::UpdateActiveSupport', :if => (
-  Gem.loaded_specs['rails'] &&
-  Gem.loaded_specs['rails'].version < Gem::Version.create('4.0')
-) do
-  require 'appsignal/update_active_support'
-  let(:pattern)  { 'foo' }
-  let(:delegate) { double }
-  before { ActiveSupport::Notifications.subscribe(pattern, delegate) }
-
-  it "should transfer old subscriptions to the new version" do
-    expect( ActiveSupport::Notifications ).to receive(:subscribe).with(pattern, delegate)
-  end
-
-  after { Appsignal::UpdateActiveSupport.run }
-end

data/spec/support/helpers/notification_helpers.rb

@@ -1,14 +0,0 @@
-module NotificationHelpers
-  def notification_event(args={})
-    args = {
-      :name => 'process_action.action_controller',
-      :start => fixed_time,
-      :ending => fixed_time + 0.1,
-      :tid => '1',
-      :payload => http_request_env_with_data
-    }.merge(args)
-    ActiveSupport::Notifications::Event.new(
-      args[:name], args[:start], args[:ending], args[:tid], args[:payload]
-    )
-  end
-end