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

data/lib/appsignal/instrumentations/net_http.rb

@@ -1,17 +0,0 @@
-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',
-      :protocol => use_ssl? ? 'https' : 'http',
-      :domain   => request['host'] || self.address,
-      :path     => request.path,
-      :method   => request.method
-    ) do
-      request_without_appsignal(request, body, &block)
-    end
-  end
-end

data/lib/appsignal/instrumentations/redis.rb

@@ -1,13 +0,0 @@
-if defined?(::Redis)
-  Appsignal.logger.info("Loading Redis (#{ Redis::VERSION }) integration")
-
-  ::Redis::Client.class_eval do
-    alias process_without_appsignal process
-
-    def process(commands, &block)
-      ActiveSupport::Notifications.instrument('query.redis') do
-        process_without_appsignal(commands, &block)
-      end
-    end
-  end
-end

data/lib/appsignal/instrumentations/sequel.rb

@@ -1,31 +0,0 @@
-if defined?(::Sequel)
-  Appsignal.logger.info("Loading Sequel (#{ Sequel::VERSION }) integration")
-
-  module Appsignal
-    module Integrations
-      module Sequel
-        # Add query instrumentation
-        def log_yield(sql, args = nil)
-
-          # We'd like to get full sql queries in the payloads as well. To do
-          # that we need to find out a way to ask Sequel which quoting strategy
-          # is used by the adapter. We can then do something similar to the AR
-          # formatter.
-
-          ActiveSupport::Notifications.instrument('sql.sequel') do
-            yield
-          end
-        end
-      end # Sequel
-    end # Integrations
-  end # Appsignal
-
-  # Register the extension...
-  Sequel::Database.register_extension(
-    :appsignal_integration,
-    Appsignal::Integrations::Sequel
-  )
-
-  # ... and automatically add it to future instances.
-  Sequel::Database.extension(:appsignal_integration)
-end

data/lib/appsignal/integrations/celluloid.rb

@@ -1,19 +0,0 @@
-if defined?(::Celluloid)
-  Appsignal.logger.info('Loading Celluloid integration')
-
-  # Some versions of Celluloid have race conditions while exiting
-  # that can result in a dead lock. We stop appsignal before shutting
-  # down Celluloid so we're sure our thread does not aggravate this situation.
-  # This way we also make sure any outstanding transactions get flushed.
-
-  ::Celluloid.class_eval do
-    class << self
-      alias shutdown_without_appsignal shutdown
-
-      def shutdown
-        Appsignal.stop
-        shutdown_without_appsignal
-      end
-    end
-  end
-end

data/lib/appsignal/integrations/delayed_job.rb

@@ -1,44 +0,0 @@
-if defined?(::Delayed::Plugin)
-  Appsignal.logger.info('Loading Delayed Job integration')
-
-  module Appsignal
-    module Integrations
-      class DelayedPlugin < ::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
-  ::Delayed::Worker.plugins << Appsignal::Integrations::DelayedPlugin
-end

data/lib/appsignal/integrations/passenger.rb

@@ -1,11 +0,0 @@
-if defined?(::PhusionPassenger)
-  Appsignal.logger.info('Loading Passenger integration')
-
-  ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
-    Appsignal.forked
-  end
-
-  ::PhusionPassenger.on_event(:stopping_worker_process) do
-    Appsignal.stop
-  end
-end

data/lib/appsignal/integrations/puma.rb

@@ -1,10 +0,0 @@
-if defined?(::Puma) && ::Puma.respond_to?(:cli_config)
-  Appsignal.logger.info('Loading Puma integration')
-
-  if ::Puma.cli_config
-    ::Puma.cli_config.options[:before_worker_shutdown] ||= []
-    ::Puma.cli_config.options[:before_worker_shutdown] << Proc.new do |id|
-      Appsignal.stop
-    end
-  end
-end

data/lib/appsignal/integrations/rails.rb

@@ -1,43 +0,0 @@
-if defined?(::Rails)
-  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
-end

data/lib/appsignal/integrations/rake.rb

@@ -1,30 +0,0 @@
-module Rake
-  class Task
-    alias_method :invoke_without_appsignal, :invoke
-
-    def invoke(*args)
-      if Appsignal.active?
-        invoke_with_appsignal(*args)
-      else
-        invoke_without_appsignal(*args)
-      end
-    end
-
-    def invoke_with_appsignal(*args)
-      invoke_without_appsignal(*args)
-    rescue => error
-      transaction = Appsignal::Transaction.create(
-        SecureRandom.uuid,
-        Appsignal::Transaction::BACKGROUND_JOB,
-        Appsignal::Transaction::GenericRequest.new(
-          :params => args
-        )
-      )
-      transaction.set_action(name)
-      transaction.set_error(error)
-      transaction.complete!
-      Appsignal.stop
-      raise error
-    end
-  end
-end

data/lib/appsignal/integrations/resque.rb

@@ -1,22 +0,0 @@
-if defined?(::Resque)
-  Appsignal.logger.info('Loading Resque integration')
-
-  module Appsignal
-    module Integrations
-      module ResquePlugin
-        def around_perform_resque_plugin(*args)
-          Appsignal.monitor_single_transaction(
-            'perform_job.resque',
-            :class => self.to_s,
-            :method => 'perform'
-          ) do
-            yield
-          end
-        end
-      end
-    end
-  end
-
-  # Extend the default job class with AppSignal instrumentation
-  Resque::Job.send(:extend, Appsignal::Integrations::ResquePlugin)
-end

data/lib/appsignal/integrations/sidekiq.rb

@@ -1,62 +0,0 @@
-if defined?(::Sidekiq)
-  Appsignal.logger.info('Loading Sidekiq integration')
-
-  module Appsignal
-    module Integrations
-      class SidekiqPlugin
-        def job_keys
-          @job_keys ||= Set.new(%w(
-            class args retried_at failed_at
-            error_message error_class backtrace
-            error_backtrace enqueued_at retry
-          ))
-        end
-
-        def call(worker, item, queue)
-          Appsignal.monitor_transaction(
-            'perform_job.sidekiq',
-            :class       => item['wrapped'] || item['class'],
-            :method      => 'perform',
-            :metadata    => formatted_metadata(item),
-            :params      => format_args(item['args']),
-            :queue_start => item['enqueued_at']
-          ) do
-            yield
-          end
-        end
-
-        def formatted_metadata(item)
-          {}.tap do |hsh|
-            item.each do |key, val|
-              hsh[key] = truncate(string_or_inspect(val)) unless job_keys.include?(key)
-            end
-          end
-        end
-
-        def string_or_inspect(string_or_other)
-          if string_or_other.is_a?(String)
-            string_or_other
-          else
-            string_or_other.inspect
-          end
-        end
-
-        def format_args(args)
-          args.map do |arg|
-            truncate(string_or_inspect(arg))
-          end
-        end
-
-        def truncate(text)
-          text.size > 200 ? "#{text[0...197]}..." : text
-        end
-      end
-    end
-  end
-
-  Sidekiq.configure_server do |config|
-    config.server_middleware do |chain|
-      chain.add Appsignal::Integrations::SidekiqPlugin
-    end
-  end
-end

data/lib/appsignal/integrations/unicorn.rb

@@ -1,28 +0,0 @@
-if defined?(::Unicorn)
-  Appsignal.logger.info('Loading Unicorn integration')
-
-  # Make sure the 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.
-
-  class Unicorn::HttpServer
-    alias_method :original_worker_loop, :worker_loop
-
-    def worker_loop(worker)
-      Appsignal.forked
-      original_worker_loop(worker)
-    end
-  end
-
-  class Unicorn::Worker
-    alias_method :original_close, :close
-
-    def close
-      Appsignal.stop
-      original_close
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'spec_helper'
-require File.expand_path('lib/appsignal/instrumentations/net_http')
-
-describe "Net::HTTP instrumentation" do
-  let(:events) { [] }
-  before do
-    ActiveSupport::Notifications.subscribe(/^[^!]/) do |*args|
-      events << ActiveSupport::Notifications::Event.new(*args)
-    end
-  end
-
-  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

data/spec/lib/appsignal/instrumentations/redis_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe "Net::HTTP instrumentation" do
-  let(:file) { File.expand_path('lib/appsignal/instrumentations/redis.rb') }
-
-  let(:events) { [] }
-  before do
-    ActiveSupport::Notifications.subscribe(/^[^!]/) do |*args|
-      events << ActiveSupport::Notifications::Event.new(*args)
-    end
-  end
-
-  context "with redis" do
-    before :all do
-      module Redis
-        class Client
-          def process(commands, &block)
-            1
-          end
-        end
-        VERSION = '1.0'
-      end
-    end
-
-    before do
-      load file
-    end
-
-    it "should generate an event for a redis call" do
-      client = Redis::Client.new
-
-      client.process([]).should == 1
-
-      event = events.last
-      event.name.should == 'query.redis'
-    end
-  end
-
-  context "without redis" do
-    before(:all) { Object.send(:remove_const, :Redis) }
-
-    specify { expect { ::Redis }.to raise_error(NameError) }
-    specify { expect { load file }.to_not raise_error }
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe "Passenger integration" do
-  let(:file) { File.expand_path('lib/appsignal/integrations/passenger.rb') }
-  before(:all) do
-    module PhusionPassenger
-    end
-  end
-
-  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)
-    load file
-  end
-
-  context "without passenger" do
-    before(:all) { Object.send(:remove_const, :PhusionPassenger) }
-
-    specify { expect { PhusionPassenger }.to raise_error(NameError) }
-    specify { expect { load file }.to_not raise_error }
-  end
-end