appsignal 0.12.rc.7 → 0.12.rc.8

data/lib/appsignal/hooks/unicorn.rb

@@ -0,0 +1,39 @@
+module Appsignal
+  class Hooks
+    class UnicornHook < Appsignal::Hooks::Hook
+      register :unicorn
+
+      def dependencies_present?
+        defined?(::Unicorn::HttpServer) &&
+          defined?(::Unicorn::Worker)
+      end
+
+      def install
+        # Make sure that appsignal is started and the last transaction
+        # in a worker gets flushed.
+        #
+        # We'd love to be able to hook this into Unicorn in a less
+        # intrusive way, but this is the best we can do given the
+        # options we have.
+
+        ::Unicorn::HttpServer.class_eval do
+          alias worker_loop_without_appsignal worker_loop
+
+          def worker_loop(worker)
+            Appsignal.forked
+            worker_loop_without_appsignal(worker)
+          end
+        end
+
+        ::Unicorn::Worker.class_eval do
+          alias close_without_appsignal close
+
+          def close
+            Appsignal.stop
+            close_without_appsignal
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/capistrano/capistrano_2_tasks.rb

@@ -1,36 +1,34 @@
 module Appsignal
-  module Integrations
-    class Capistrano
-      def self.tasks(config)
-        config.load do
-          after 'deploy', 'appsignal:deploy'
-          after 'deploy:migrations', 'appsignal:deploy'
+  class Capistrano
+    def self.tasks(config)
+      config.load do
+        after 'deploy', 'appsignal:deploy'
+        after 'deploy:migrations', 'appsignal:deploy'
 
-          namespace :appsignal do
-            task :deploy do
-              env = fetch(:rails_env, fetch(:rack_env, 'production'))
-              user = ENV['USER'] || ENV['USERNAME']
-              revision = fetch(:appsignal_revision, fetch(:current_revision))
+        namespace :appsignal do
+          task :deploy do
+            env = fetch(:rails_env, fetch(:rack_env, 'production'))
+            user = ENV['USER'] || ENV['USERNAME']
+            revision = fetch(:appsignal_revision, fetch(:current_revision))
 
-              appsignal_config = Appsignal::Config.new(
-                ENV['PWD'],
-                env,
-                fetch(:appsignal_config, {}),
-                logger
-              )
+            appsignal_config = Appsignal::Config.new(
+              ENV['PWD'],
+              env,
+              fetch(:appsignal_config, {}),
+              logger
+            )
 
-              if appsignal_config && appsignal_config.active?
-                marker_data = {
-                  :revision => revision,
-                  :user => user
-                }
+            if appsignal_config && appsignal_config.active?
+              marker_data = {
+                :revision => revision,
+                :user => user
+              }
 
-                marker = Marker.new(marker_data, appsignal_config, logger)
-                if config.dry_run
-                  logger.info('Dry run: Deploy marker not actually sent.')
-                else
-                  marker.transmit
-                end
+              marker = Marker.new(marker_data, appsignal_config, logger)
+              if config.dry_run
+                logger.info('Dry run: Deploy marker not actually sent.')
+              else
+                marker.transmit
               end
             end
           end
@@ -41,5 +39,5 @@ module Appsignal
 end
 
 if ::Capistrano::Configuration.instance
-  Appsignal::Integrations::Capistrano.tasks(::Capistrano::Configuration.instance)
+  Appsignal::Capistrano.tasks(::Capistrano::Configuration.instance)
 end

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -0,0 +1,39 @@
+module Appsignal
+  class Hooks
+    class DelayedJobPlugin < ::Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, &block|
+          invoke_with_instrumentation(job, block)
+        end
+
+        lifecycle.after(:loop) do |loop|
+          Appsignal.stop
+        end
+      end
+
+      def self.invoke_with_instrumentation(job, block)
+        class_and_method_name = if job.payload_object.respond_to?(:appsignal_name)
+                                  job.payload_object.appsignal_name
+                                else
+                                  job.name
+                                end
+        class_name, method_name = class_and_method_name.split('#')
+
+        Appsignal.monitor_transaction(
+          'perform_job.delayed_job',
+          :class    => class_name,
+          :method   => method_name,
+          :metadata => {
+            :id       => job.id,
+            :queue    => job.queue,
+            :priority => job.priority || 0,
+            :attempts => job.attempts || 0
+          },
+          :queue_start => job.created_at
+        ) do
+          block.call(job)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/railtie.rb

@@ -0,0 +1,41 @@
+Appsignal.logger.info("Loading Rails (#{Rails.version}) integration")
+
+require 'appsignal/rack/rails_instrumentation'
+
+module Appsignal
+  module Integrations
+    class Railtie < ::Rails::Railtie
+      initializer 'appsignal.configure_rails_initialization' do |app|
+        Appsignal::Integrations::Railtie.initialize_appsignal(app)
+      end
+
+      def self.initialize_appsignal(app)
+        # Load config
+        Appsignal.config = Appsignal::Config.new(
+          Rails.root,
+          ENV.fetch('APPSIGNAL_APP_ENV', Rails.env),
+          :name => Rails.application.class.parent_name,
+          :log_file_path => Rails.root.join('log/appsignal.log')
+        )
+
+        # Start logger
+        Appsignal.start_logger
+
+        app.middleware.insert_before(
+          ActionDispatch::RemoteIp,
+          Appsignal::Rack::RailsInstrumentation
+        )
+
+        if Appsignal.config.active? &&
+          Appsignal.config[:enable_frontend_error_catching] == true
+          app.middleware.insert_before(
+            Appsignal::Rack::RailsInstrumentation,
+            Appsignal::Rack::JSExceptionCatcher,
+          )
+        end
+
+        Appsignal.start
+      end
+    end
+  end
+end

data/lib/appsignal/transaction.rb

@@ -156,11 +156,16 @@ module Appsignal
       cleaned_value = env_var.tr('^0-9'.freeze, ''.freeze)
       return if cleaned_value.empty?
       value = cleaned_value.to_i
-      [1_000_000.0, 1_000.0].each do |factor|
-        queue_start = (value / factor).to_i
-        return queue_start if queue_start > 946_681_200 # Ok if it's later than 2000
+      if value > 4_102_441_200_000
+        # Value is in microseconds
+        value / 1_000
+      elsif value < 946_681_200_000
+        # Value is to low to be plausible
+        nil
+      else
+        # Value is in milliseconds
+        value
       end
-      nil
     end
 
     def sanitized_params

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 require 'yaml'
 
 module Appsignal
-  VERSION = '0.12.rc.7'
+  VERSION = '0.12.rc.8'
 end

data/spec/lib/appsignal/{integrations/capistrano2_spec.rb → capistrano2_spec.rb}

@@ -10,7 +10,7 @@ if capistrano2_present?
 
     before :all do
       @capistrano_config = Capistrano::Configuration.new
-      Appsignal::Integrations::Capistrano.tasks(@capistrano_config)
+      Appsignal::Capistrano.tasks(@capistrano_config)
     end
 
     it "should have a deploy task" do

data/spec/lib/appsignal/{integrations → hooks}/celluloid_spec.rb

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
-describe "Celluloid integration" do
-  let(:file) { File.expand_path('lib/appsignal/integrations/celluloid.rb') }
-
+describe Appsignal::Hooks::CelluloidHook do
   context "with celluloid" do
-    before(:all) do
+    before :all do
       module Celluloid
         def self.shutdown
         end
       end
+      Appsignal::Hooks::CelluloidHook.new.install
     end
-
-    before do
-      load file
+    after :all do
+      Object.send(:remove_const, :Celluloid)
     end
 
+    its(:dependencies_present?) { should be_true }
+
     specify { expect(Appsignal).to receive(:stop) }
     specify { expect(Celluloid).to receive(:shutdown_without_appsignal) }
 
@@ -24,9 +24,6 @@ describe "Celluloid integration" do
   end
 
   context "without celluloid" do
-    before(:all) { Object.send(:remove_const, :Celluloid) }
-
-    specify { expect { ::Celluloid }.to raise_error(NameError) }
-    specify { expect { load file }.to_not raise_error }
+    its(:dependencies_present?) { should be_false }
   end
 end

data/spec/lib/appsignal/{integrations → hooks}/delayed_job_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
-describe "Delayed Job integration" do
-  let(:file) { File.expand_path('lib/appsignal/integrations/delayed_job.rb') }
-
+describe Appsignal::Hooks::DelayedJobHook do
   context "with delayed job" do
     before(:all) do
       module Delayed
@@ -18,15 +16,17 @@ describe "Delayed Job integration" do
         end
       end
     end
+    after(:all) { Object.send(:remove_const, :Delayed) }
     before do
-      load file
       start_agent
     end
 
+    its(:dependencies_present?) { should be_true }
+
     # We haven't found a way to test the hooks, we'll have to do that manually
 
     describe ".invoke_with_instrumentation" do
-      let(:plugin) { Appsignal::Integrations::DelayedPlugin }
+      let(:plugin) { Appsignal::Hooks::DelayedJobPlugin }
       let(:time) { Time.parse('01-01-2001 10:01:00UTC') }
       let(:job) do
         double(
@@ -112,14 +112,11 @@ describe "Delayed Job integration" do
     end
 
     it "should add the plugin" do
-      ::Delayed::Worker.plugins.should include Appsignal::Integrations::DelayedPlugin
+      ::Delayed::Worker.plugins.should include Appsignal::Hooks::DelayedJobPlugin
     end
   end
 
   context "without delayed job" do
-    before(:all) { Object.send(:remove_const, :Delayed) }
-
-    specify { expect { ::Delayed }.to raise_error(NameError) }
-    specify { expect { load file }.to_not raise_error }
+    its(:dependencies_present?) { should be_false }
   end
 end

data/spec/lib/appsignal/hooks/net_http_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Appsignal::Hooks::NetHttpHook do
+  before :all do
+    Appsignal.config = project_fixture_config
+  end
+
+  context "with Net::HTTP instrumentation enabled" do
+    let(:events) { [] }
+    before :all do
+      Appsignal.config.config_hash[:instrument_net_http] = true
+    end
+    before do
+      ActiveSupport::Notifications.subscribe(/^[^!]/) do |*args|
+        events << ActiveSupport::Notifications::Event.new(*args)
+      end
+    end
+    after(:all) { Appsignal.config.config_hash[:instrument_net_http] = false }
+
+    its(:dependencies_present?) { should be_true }
+
+    it "should generate an event for a http request" do
+      stub_request(:any, 'http://www.google.com/')
+
+      Net::HTTP.get_response(URI.parse('http://www.google.com'))
+
+      event = events.last
+      event.name.should == 'request.net_http'
+      event.payload[:protocol].should == 'http'
+      event.payload[:domain].should == 'www.google.com'
+      event.payload[:path].should == '/'
+      event.payload[:method].should == 'GET'
+    end
+
+    it "should generate an event for a https request" do
+      stub_request(:any, 'https://www.google.com/')
+
+      uri = URI.parse('https://www.google.com')
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.get(uri.request_uri)
+
+      event = events.last
+      event.name.should == 'request.net_http'
+      event.payload[:protocol].should == 'https'
+      event.payload[:domain].should == 'www.google.com'
+      event.payload[:path].should == '/'
+      event.payload[:method].should == 'GET'
+    end
+  end
+
+  context "with Net::HTTP instrumentation disabled" do
+    its(:dependencies_present?) { should be_false }
+  end
+end

data/spec/lib/appsignal/hooks/passenger_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Appsignal::Hooks::PassengerHook do
+  context "with passenger" do
+    before(:all) do
+      module PhusionPassenger
+      end
+    end
+    after(:all) { Object.send(:remove_const, :PhusionPassenger) }
+
+    its(:dependencies_present?) { should be_true }
+
+    it "adds behavior to stopping_worker_process and starting_worker_process" do
+      PhusionPassenger.should_receive(:on_event).with(:starting_worker_process)
+      PhusionPassenger.should_receive(:on_event).with(:stopping_worker_process)
+
+      Appsignal::Hooks::PassengerHook.new.install
+    end
+  end
+
+  context "without passenger" do
+    its(:dependencies_present?) { should be_false }
+  end
+end

data/spec/lib/appsignal/hooks/puma_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Appsignal::Hooks::PumaHook do
+  context "with puma" do
+    before(:all) do
+      class Puma
+        def self.cli_config
+          @cli_config ||= CliConfig.new
+        end
+      end
+
+      class CliConfig
+        attr_accessor :options
+
+        def initialize
+          @options = {}
+        end
+      end
+    end
+    after(:all) { Object.send(:remove_const, :Puma) }
+
+    its(:dependencies_present?) { should be_true }
+
+    context "with a nil before worker shutdown" do
+      before do
+        Puma.cli_config.options.delete(:before_worker_shutdown)
+        Appsignal::Hooks::PumaHook.new.install
+      end
+
+      it "should add a before shutdown worker callback" do
+        Puma.cli_config.options[:before_worker_shutdown].first.should be_a(Proc)
+      end
+    end
+
+    context "with an existing before worker shutdown" do
+      before do
+        Puma.cli_config.options[:before_worker_shutdown] = []
+        Appsignal::Hooks::PumaHook.new.install
+      end
+
+      it "should add a before shutdown worker callback" do
+        Puma.cli_config.options[:before_worker_shutdown].first.should be_a(Proc)
+      end
+    end
+  end
+
+  context "without puma" do
+    its(:dependencies_present?) { should be_false }
+  end
+end