appsignal 2.5.0.alpha.1-java

data/lib/appsignal/integrations/rake.rb

@@ -0,0 +1,2 @@
+# Since version 1.0 requiring this file is not necessary anymore to get
+# Rake integration, it's just here for backward compatibility.

data/lib/appsignal/integrations/resque.rb

@@ -0,0 +1,20 @@
+module Appsignal
+  module Integrations
+    # @api private
+    module ResquePlugin
+      # Do not use this file as a template for your own background processor
+      # Resque is an exception to the rule and the code below causes the
+      # extension to shut itself down after a single job.
+      # see http://docs.appsignal.com/background-monitoring/custom.html
+      def around_perform_resque_plugin(*_args)
+        Appsignal.monitor_single_transaction(
+          "perform_job.resque",
+          :class => to_s,
+          :method => "perform"
+        ) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/resque_active_job.rb

@@ -0,0 +1,30 @@
+module Appsignal
+  module Integrations
+    # @api private
+    module ResqueActiveJobPlugin
+      include Appsignal::Hooks::Helpers
+
+      def self.included(base)
+        base.class_eval do
+          around_perform do |job, block|
+            params = Appsignal::Utils::ParamsSanitizer.sanitize job.arguments,
+              :filter_parameters => Appsignal.config[:filter_parameters]
+
+            Appsignal.monitor_single_transaction(
+              "perform_job.resque",
+              :class    => job.class.to_s,
+              :method   => "perform",
+              :params   => params,
+              :metadata => {
+                :id       => job.job_id,
+                :queue    => job.queue_name
+              }
+            ) do
+              block.call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/sinatra.rb

@@ -0,0 +1,17 @@
+require "appsignal"
+require "appsignal/rack/sinatra_instrumentation"
+
+Appsignal.logger.info("Loading Sinatra (#{Sinatra::VERSION}) integration")
+
+app_settings = ::Sinatra::Application.settings
+Appsignal.config = Appsignal::Config.new(
+  app_settings.root || Dir.pwd,
+  app_settings.environment
+)
+
+Appsignal.start_logger
+Appsignal.start
+
+if Appsignal.active?
+  ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation)
+end

data/lib/appsignal/integrations/webmachine.rb

@@ -0,0 +1,38 @@
+module Appsignal
+  module Integrations
+    # @api private
+    module WebmachinePlugin
+      module FSM
+        def run_with_appsignal
+          transaction = Appsignal::Transaction.create(
+            SecureRandom.uuid,
+            Appsignal::Transaction::HTTP_REQUEST,
+            request,
+            :params_method => :query
+          )
+
+          transaction.set_action_if_nil("#{resource.class.name}##{request.method}")
+
+          Appsignal.instrument("process_action.webmachine") do
+            run_without_appsignal
+          end
+
+          Appsignal::Transaction.complete_current!
+        end
+
+        private
+
+        def handle_exceptions_with_appsignal
+          handle_exceptions_without_appsignal do
+            begin
+              yield
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              Appsignal.set_error(e)
+              raise e
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/js_exception_transaction.rb

@@ -0,0 +1,54 @@
+module Appsignal
+  class JSExceptionTransaction
+    attr_reader :uuid, :ext
+
+    def initialize(data)
+      @data = data
+      @uuid = SecureRandom.uuid
+      @ext = Appsignal::Extension.start_transaction(@uuid, Appsignal::Transaction::FRONTEND, 0)
+
+      set_action
+      set_metadata
+      set_error
+      set_sample_data
+    end
+
+    def set_action
+      return unless @data["action"]
+      ext.set_action(@data["action"])
+    end
+
+    def set_metadata
+      return unless @data["path"]
+      ext.set_metadata("path", @data["path"])
+    end
+
+    def set_error
+      ext.set_error(
+        @data["name"],
+        @data["message"] || "",
+        Appsignal::Utils.data_generate(@data["backtrace"] || [])
+      )
+    end
+
+    def set_sample_data
+      {
+        :params       => @data["params"],
+        :session_data => @data["session_data"],
+        :environment  => @data["environment"],
+        :tags         => @data["tags"]
+      }.each do |key, data|
+        next unless data.is_a?(Array) || data.is_a?(Hash)
+        ext.set_sample_data(
+          key.to_s,
+          Appsignal::Utils.data_generate(data)
+        )
+      end
+    end
+
+    def complete!
+      ext.finish(0)
+      ext.complete
+    end
+  end
+end

data/lib/appsignal/marker.rb

@@ -0,0 +1,63 @@
+module Appsignal
+  # Deploy markers are used on AppSignal.com to indicate changes in an
+  # application, "Deploy markers" indicate a deploy of an application.
+  #
+  # Incidents for exceptions and performance issues will be closed and
+  # reopened if they occur again in the new deploy.
+  #
+  # This class will help send a request to the AppSignal Push API to create a
+  # Deploy marker for the application on AppSignal.com.
+  #
+  # @!attribute [r] marker_data
+  #   @return [Hash] marker data to send.
+  #
+  # @!attribute [r] config
+  #   @return [Appsignal::Config] config to use in the authentication request.
+  #     Set config does not override data set in {#marker_data}.
+  #
+  # @see Appsignal::CLI::NotifyOfDeploy
+  # @see http://docs.appsignal.com/appsignal/terminology.html#markers
+  #   Terminology: Deploy marker
+  # @api private
+  class Marker
+    # Path used on the AppSignal Push API
+    # https://push.appsignal.com/1/markers
+    ACTION = "markers".freeze
+
+    attr_reader :marker_data, :config
+
+    # @param marker_data [Hash] see {#marker_data}
+    # @option marker_data :environment [String] environment to load
+    #   configuration for.
+    # @option marker_data :name [String] name of the application.
+    # @option marker_data :user [String] name of the user that is creating the
+    #   marker.
+    # @option marker_data :revision [String] the revision that has been
+    #   deployed. E.g. a git commit SHA.
+    # @param config [Appsignal::Config]
+    def initialize(marker_data, config)
+      @marker_data = marker_data
+      @config = config
+    end
+
+    # Send a request to create the marker.
+    #
+    # Prints output to STDOUT.
+    #
+    # @return [void]
+    def transmit
+      transmitter = Transmitter.new(ACTION, config)
+      puts "Notifying AppSignal of deploy with: "\
+        "revision: #{marker_data[:revision]}, user: #{marker_data[:user]}"
+
+      response = transmitter.transmit(marker_data)
+      if response.code == "200"
+        puts "AppSignal has been notified of this deploy!"
+      else
+        raise "#{response.code} at #{transmitter.uri}"
+      end
+    rescue => e
+      puts "Something went wrong while trying to notify AppSignal: #{e}"
+    end
+  end
+end

data/lib/appsignal/minutely.rb

@@ -0,0 +1,42 @@
+module Appsignal
+  # @api private
+  class Minutely
+    class << self
+      # List of probes. Probes can be lamdba's or objects that
+      # respond to call.
+      def probes
+        @@probes ||= []
+      end
+
+      def start
+        Thread.new do
+          begin
+            loop do
+              Appsignal.logger.debug("Gathering minutely metrics with #{probes.count} probe(s)")
+              probes.each(&:call)
+              sleep(wait_time)
+            end
+          rescue => ex
+            Appsignal.logger.error("Error in minutely thread: #{ex}")
+          end
+        end
+      end
+
+      def wait_time
+        60 - Time.now.sec
+      end
+
+      def add_gc_probe
+        probes << GCProbe.new
+      end
+    end
+
+    class GCProbe
+      def call
+        GC.stat.each do |key, value|
+          Appsignal.set_process_gauge("gc.#{key}", value)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/rack/generic_instrumentation.rb

@@ -0,0 +1,49 @@
+require "rack"
+
+module Appsignal
+  # @api private
+  module Rack
+    class GenericInstrumentation
+      def initialize(app, options = {})
+        Appsignal.logger.debug "Initializing Appsignal::Rack::GenericInstrumentation"
+        @app = app
+        @options = options
+      end
+
+      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
+          Appsignal.instrument("process_action.generic") do
+            @app.call(env)
+          end
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          transaction.set_error(error)
+          raise error
+        ensure
+          if env["appsignal.route"]
+            transaction.set_action_if_nil(env["appsignal.route"])
+          else
+            transaction.set_action_if_nil("unknown")
+          end
+          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
+    end
+  end
+end

data/lib/appsignal/rack/js_exception_catcher.rb

@@ -0,0 +1,70 @@
+module Appsignal
+  # @api private
+  module Rack
+    # JavaScript error catching middleware.
+    #
+    # Listens to the endpoint specified in the `frontend_error_catching_path`
+    # configuration option.
+    #
+    # This is automatically included middleware in Rails apps if the
+    # `frontend_error_catching_path` configuration option is active.
+    #
+    # If AppSignal is not active in the current environment, but does have
+    # JavaScript error catching turned on, we assume that a JavaScript script
+    # still sends errors to this endpoint. When AppSignal is not active in this
+    # scenario this middleware still listens to the endpoint, but won't record
+    # the error. It will return HTTP status code 202.
+    #
+    # @example with a Sinatra app
+    #   Sinatra::Application.use(Appsignal::Rack::JSExceptionCatcher)
+    #
+    # @see http://docs.appsignal.com/front-end/error-handling.html
+    # @api private
+    class JSExceptionCatcher
+      def initialize(app, _options = nil)
+        Appsignal.logger.debug \
+          "Initializing Appsignal::Rack::JSExceptionCatcher"
+        @app = app
+      end
+
+      def call(env)
+        # Ignore other paths than the error catching path.
+        return @app.call(env) unless error_cathing_endpoint?(env)
+
+        # Prevent raising a 404 not found when a non-active environment posts
+        # to this endpoint.
+        unless Appsignal.active?
+          return [
+            202,
+            {},
+            ["AppSignal JavaScript error catching endpoint is not active."]
+          ]
+        end
+
+        begin
+          body = JSON.parse(env["rack.input"].read)
+        rescue JSON::ParserError
+          return [400, {}, ["Request payload is not valid JSON."]]
+        end
+
+        if body["name"].is_a?(String) && !body["name"].empty?
+          transaction = JSExceptionTransaction.new(body)
+          transaction.complete!
+          code = 200
+        else
+          Appsignal.logger.debug \
+            "JSExceptionCatcher: Could not send exception, 'name' is empty."
+          code = 422
+        end
+
+        [code, {}, []]
+      end
+
+      private
+
+      def error_cathing_endpoint?(env)
+        env["PATH_INFO"] == Appsignal.config[:frontend_error_catching_path]
+      end
+    end
+  end
+end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -0,0 +1,51 @@
+require "rack"
+
+module Appsignal
+  # @api private
+  module Rack
+    class RailsInstrumentation
+      def initialize(app, options = {})
+        Appsignal.logger.debug "Initializing Appsignal::Rack::RailsInstrumentation"
+        @app = app
+        @options = options
+      end
+
+      def call(env)
+        if Appsignal.active?
+          call_with_appsignal_monitoring(env)
+        else
+          @app.call(env)
+        end
+      end
+
+      def call_with_appsignal_monitoring(env)
+        request = ActionDispatch::Request.new(env)
+        transaction = Appsignal::Transaction.create(
+          request_id(env),
+          Appsignal::Transaction::HTTP_REQUEST,
+          request,
+          :params_method => :filtered_parameters
+        )
+        begin
+          @app.call(env)
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          transaction.set_error(error)
+          raise error
+        ensure
+          controller = env["action_controller.instance"]
+          if controller
+            transaction.set_action_if_nil("#{controller.class}##{controller.action_name}")
+          end
+          transaction.set_http_or_background_queue_start
+          transaction.set_metadata("path", request.path)
+          transaction.set_metadata("method", request.request_method)
+          Appsignal::Transaction.complete_current!
+        end
+      end
+
+      def request_id(env)
+        env["action_dispatch.request_id"] || SecureRandom.uuid
+      end
+    end
+  end
+end