appsignal 2.5.0.alpha.1-java

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

@@ -0,0 +1,52 @@
+module Appsignal
+  # @todo Move to sub-namespace
+  # @api private
+  class Capistrano
+    def self.tasks(config)
+      config.load do # rubocop:disable Metrics/BlockLength
+        after "deploy", "appsignal:deploy"
+        after "deploy:migrations", "appsignal:deploy"
+
+        namespace :appsignal do
+          task :deploy do
+            env = fetch(:appsignal_env, fetch(:stage, fetch(:rails_env, fetch(:rack_env, "production"))))
+            user = fetch(:appsignal_user, ENV["USER"] || ENV["USERNAME"])
+            revision = fetch(:appsignal_revision, fetch(:current_revision))
+
+            appsignal_config = Appsignal::Config.new(
+              ENV["PWD"],
+              env,
+              {},
+              Logger.new(StringIO.new)
+            ).tap do |c|
+              fetch(:appsignal_config, {}).each do |key, value|
+                c[key] = value
+              end
+              c.validate
+            end
+
+            if appsignal_config && appsignal_config.active?
+              marker_data = {
+                :revision => revision,
+                :user => user
+              }
+
+              marker = Marker.new(marker_data, appsignal_config)
+              if config.dry_run
+                puts "Dry run: AppSignal deploy marker not actually sent."
+              else
+                marker.transmit
+              end
+            else
+              puts "Not notifying of deploy, config is not active for environment: #{env}"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+if ::Capistrano::Configuration.instance
+  Appsignal::Capistrano.tasks(::Capistrano::Configuration.instance)
+end

data/lib/appsignal/integrations/data_mapper.rb

@@ -0,0 +1,33 @@
+module Appsignal
+  class Hooks
+    module DataMapperLogListener
+      SQL_CLASSES = [
+        "DataObjects::SqlServer::Connection",
+        "DataObjects::Sqlite3::Connection",
+        "DataObjects::Mysql::Connection",
+        "DataObjects::Postgres::Connection"
+      ].freeze
+
+      def log(message)
+        # If scheme is SQL-like, try to sanitize it, otherwise clear the body
+        if SQL_CLASSES.include?(self.class.to_s)
+          body_content = message.query
+          body_format = Appsignal::EventFormatter::SQL_BODY_FORMAT
+        else
+          body_content = ""
+          body_format = Appsignal::EventFormatter::DEFAULT
+        end
+
+        # Record event
+        Appsignal::Transaction.current.record_event(
+          "query.data_mapper",
+          "DataMapper Query",
+          body_content,
+          message.duration,
+          body_format
+        )
+        super
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -0,0 +1,54 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class DelayedJobPlugin < ::Delayed::Plugin
+      extend Appsignal::Hooks::Helpers
+
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, &block|
+          invoke_with_instrumentation(job, block)
+        end
+
+        lifecycle.after(:execute) do |_execute|
+          Appsignal.stop("delayed job")
+        end
+      end
+
+      def self.invoke_with_instrumentation(job, block)
+        payload = job.payload_object
+
+        if payload.respond_to? :job_data
+          # ActiveJob
+          job_data = payload.job_data
+          args = job_data.fetch("arguments", {})
+          class_name = job_data["job_class"]
+          method_name = "perform"
+        else
+          # Delayed Job
+          args = extract_value(job.payload_object, :args, {})
+          class_and_method_name = extract_value(job.payload_object, :appsignal_name, job.name)
+          class_name, method_name = class_and_method_name.split("#")
+        end
+
+        params = Appsignal::Utils::ParamsSanitizer.sanitize args,
+          :filter_parameters => Appsignal.config[:filter_parameters]
+
+        Appsignal.monitor_transaction(
+          "perform_job.delayed_job",
+          :class    => class_name,
+          :method   => method_name,
+          :metadata => {
+            :id       => extract_value(job, :id, nil, true),
+            :queue    => extract_value(job, :queue),
+            :priority => extract_value(job, :priority, 0),
+            :attempts => extract_value(job, :attempts, 0)
+          },
+          :params      => params,
+          :queue_start => extract_value(job, :run_at)
+        ) do
+          block.call(job)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/grape.rb

@@ -0,0 +1,53 @@
+module Appsignal
+  # @todo Move to sub-namespace
+  # @api private
+  module Grape
+    class Middleware < ::Grape::Middleware::Base
+      def call(env)
+        if Appsignal.active?
+          call_with_appsignal_monitoring(env)
+        else
+          app.call(env)
+        end
+      end
+
+      def call_with_appsignal_monitoring(env)
+        request     = ::Rack::Request.new(env)
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::HTTP_REQUEST,
+          request
+        )
+        begin
+          app.call(env)
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          transaction.set_error(error)
+          raise error
+        ensure
+          request_method = request.request_method.to_s.upcase
+          path = request.path # Path without namespaces
+          endpoint = env["api.endpoint"]
+
+          if endpoint && endpoint.options
+            options = endpoint.options
+            request_method = options[:method].first.to_s.upcase
+            klass = options[:for]
+            namespace = endpoint.namespace
+            namespace = "" if namespace == "/"
+
+            path = options[:path].first.to_s
+            path = "/#{path}" if path[0] != "/"
+            path = "#{namespace}#{path}"
+
+            transaction.set_action_if_nil("#{request_method}::#{klass}##{path}")
+          end
+
+          transaction.set_http_or_background_queue_start
+          transaction.set_metadata("path", path)
+          transaction.set_metadata("method", request_method)
+          Appsignal::Transaction.complete_current!
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/mongo_ruby_driver.rb

@@ -0,0 +1,55 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class MongoMonitorSubscriber
+      # Called by Mongo::Monitor when query starts
+      def started(event)
+        transaction = Appsignal::Transaction.current
+        return if transaction.nil_transaction?
+        return if transaction.paused?
+
+        # Format the command
+        command = Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter
+          .format(event.command_name, event.command)
+
+        # Store the query on the transaction, we need it when the event finishes
+        store                   = transaction.store("mongo_driver")
+        store[event.request_id] = command
+
+        # Start this event
+        transaction.start_event
+      end
+
+      # Called by Mongo::Monitor when query succeeds
+      def succeeded(event)
+        # Finish the event as succeeded
+        finish("SUCCEEDED", event)
+      end
+
+      # Called by Mongo::Monitor when query fails
+      def failed(event)
+        # Finish the event as failed
+        finish("FAILED", event)
+      end
+
+      # Finishes the event in the AppSignal extension
+      def finish(result, event)
+        transaction = Appsignal::Transaction.current
+        return if transaction.nil_transaction?
+        return if transaction.paused?
+
+        # Get the query from the transaction store
+        store   = transaction.store("mongo_driver")
+        command = store.delete(event.request_id) || {}
+
+        # Finish the event in the extension.
+        transaction.finish_event(
+          "query.mongodb",
+          "#{event.command_name} | #{event.database_name} | #{result}",
+          Appsignal::Utils.data_generate(command),
+          Appsignal::EventFormatter::DEFAULT
+        )
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/object.rb

@@ -0,0 +1,35 @@
+class Object
+  def self.appsignal_instrument_class_method(method_name, options = {})
+    singleton_class.send \
+      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
+    singleton_class.send(:define_method, method_name) do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
+      end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
+      end
+    end
+  end
+
+  def self.appsignal_instrument_method(method_name, options = {})
+    alias_method "appsignal_uninstrumented_#{method_name}", method_name
+    define_method method_name do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.#{appsignal_reverse_class_name}.other"
+      end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
+      end
+    end
+  end
+
+  def self.appsignal_reverse_class_name
+    return "AnonymousClass" unless name
+    name.split("::").reverse.join(".")
+  end
+
+  def appsignal_reverse_class_name
+    self.class.appsignal_reverse_class_name
+  end
+end

data/lib/appsignal/integrations/padrino.rb

@@ -0,0 +1,84 @@
+require "appsignal"
+
+module Appsignal
+  module Integrations
+    # @api private
+    module PadrinoPlugin
+      def self.init
+        Appsignal.logger.info("Loading Padrino (#{Padrino::VERSION}) integration")
+
+        root = Padrino.mounted_root
+        Appsignal.config = Appsignal::Config.new(root, Padrino.env)
+
+        Appsignal.start_logger
+        Appsignal.start
+      end
+    end
+  end
+end
+
+module Padrino::Routing::InstanceMethods
+  alias route_without_appsignal route!
+
+  def route!(base = settings, pass_block = nil)
+    if !Appsignal.active? || env["sinatra.static_file"]
+      return route_without_appsignal(base, pass_block)
+    end
+
+    transaction = Appsignal::Transaction.create(
+      SecureRandom.uuid,
+      Appsignal::Transaction::HTTP_REQUEST,
+      request
+    )
+    begin
+      Appsignal.instrument("process_action.padrino") do
+        route_without_appsignal(base, pass_block)
+      end
+    rescue Exception => error # rubocop:disable Lint/RescueException
+      transaction.set_error(error)
+      raise error
+    ensure
+      transaction.set_action_if_nil(get_payload_action(request))
+      transaction.set_metadata("path", request.path)
+      transaction.set_metadata("method", request.request_method)
+      transaction.set_http_or_background_queue_start
+      Appsignal::Transaction.complete_current!
+    end
+  end
+
+  private
+
+  def get_payload_action(request)
+    # Short-circut is there's no request object to obtain information from
+    return settings.name.to_s unless request
+
+    # Newer versions expose the action / controller on the request class.
+    # Newer versions also still expose a route_obj so we must prioritize the
+    # action/fullpath methods.
+    # The `request.action` and `request.controller` values are `nil` when a
+    # endpoint is not found, `""` if not specified by the user.
+    controller_name = request.controller if request.respond_to?(:controller)
+    action_name = request.action if request.respond_to?(:action)
+    action_name ||= ""
+    if action_name.empty? && request.respond_to?(:fullpath)
+      action_name = request.fullpath
+    end
+
+    unless action_name.empty?
+      return "#{settings.name}:#{controller_name}##{action_name}"
+    end
+
+    # Older versions of Padrino work with a route object
+    if request.respond_to?(:route_obj) && request.route_obj
+      return "#{settings.name}:#{request.route_obj.original_path}"
+    end
+
+    # Fall back to the application name if we haven't found an action name in
+    # any previous methods.
+    settings.name.to_s
+  end
+end
+
+Padrino.after_load do
+  Appsignal::Integrations::PadrinoPlugin.init
+end

data/lib/appsignal/integrations/que.rb

@@ -0,0 +1,43 @@
+module Appsignal
+  module Integrations
+    module QuePlugin
+      def self.included(base)
+        base.class_eval do
+          def _run_with_appsignal
+            env = {
+              :metadata    => {
+                :id        => attrs[:job_id],
+                :queue     => attrs[:queue],
+                :run_at    => attrs[:run_at].to_s,
+                :priority  => attrs[:priority],
+                :attempts  => attrs[:error_count].to_i
+              },
+              :params => attrs[:args]
+            }
+
+            request = Appsignal::Transaction::GenericRequest.new(env)
+
+            transaction = Appsignal::Transaction.create(
+              SecureRandom.uuid,
+              Appsignal::Transaction::BACKGROUND_JOB,
+              request
+            )
+
+            begin
+              Appsignal.instrument("perform_job.que") { _run_without_appsignal }
+            rescue Exception => error # rubocop:disable Lint/RescueException
+              transaction.set_error(error)
+              raise error
+            ensure
+              transaction.set_action "#{attrs[:job_class]}#run"
+              Appsignal::Transaction.complete_current!
+            end
+          end
+
+          alias_method :_run_without_appsignal, :_run
+          alias_method :_run, :_run_with_appsignal
+        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
+    # @api private
+    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,
+          Rails.env,
+          :name => Rails.application.class.parent_name,
+          :log_path => Rails.root.join("log")
+        )
+
+        # Start logger
+        Appsignal.start_logger
+
+        app.middleware.insert_after(
+          ActionDispatch::DebugExceptions,
+          Appsignal::Rack::RailsInstrumentation
+        )
+
+        if Appsignal.config[:enable_frontend_error_catching]
+          app.middleware.insert_before(
+            Appsignal::Rack::RailsInstrumentation,
+            Appsignal::Rack::JSExceptionCatcher
+          )
+        end
+
+        Appsignal.start
+      end
+    end
+  end
+end