appsignal 2.5.0.alpha.1-java

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -0,0 +1,99 @@
+require "rack"
+
+module Appsignal
+  module Rack
+    # Stub old middleware. Prevents Sinatra middleware being loaded twice.
+    # This can happen when users use the old method of including
+    # `use Appsignal::Rack::SinatraInstrumentation` in their modular Sinatra
+    # applications. This is no longer needed. Instead Appsignal now includes
+    # `use Appsignal::Rack::SinatraBaseInstrumentation` automatically.
+    #
+    # @api private
+    class SinatraInstrumentation
+      def initialize(app, options = {})
+        @app = app
+        @options = options
+        Appsignal.logger.warn "Please remove Appsignal::Rack::SinatraInstrumentation "\
+          "from your Sinatra::Base class. This is no longer needed."
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def settings
+        @app.settings
+      end
+    end
+
+    class SinatraBaseInstrumentation
+      attr_reader :raise_errors_on
+
+      def initialize(app, options = {})
+        Appsignal.logger.debug "Initializing Appsignal::Rack::SinatraInstrumentation"
+        @app = app
+        @options = options
+        @raise_errors_on = raise_errors?(@app)
+      end
+
+      def call(env)
+        if Appsignal.active?
+          call_with_appsignal_monitoring(env)
+        else
+          @app.call(env)
+        end
+      end
+
+      def call_with_appsignal_monitoring(env)
+        if @options[:params_method]
+          env[:params_method] = @options[:params_method]
+        end
+        request = @options.fetch(:request_class, Sinatra::Request).new(env)
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::HTTP_REQUEST,
+          request,
+          :force => @options.include?(:force) && @options[:force]
+        )
+        begin
+          Appsignal.instrument("process_action.sinatra") do
+            @app.call(env)
+          end
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          transaction.set_error(error)
+          raise error
+        ensure
+          # If raise_error is off versions of Sinatra don't raise errors, but store
+          # them in the sinatra.error env var.
+          if !raise_errors_on && env["sinatra.error"] && !env["sinatra.skip_appsignal_error"]
+            transaction.set_error(env["sinatra.error"])
+          end
+          transaction.set_action_if_nil(action_name(env))
+          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
+
+      def action_name(env)
+        return unless env["sinatra.route"]
+
+        if env["SCRIPT_NAME"]
+          method, route = env["sinatra.route"].split(" ")
+          "#{method} #{env["SCRIPT_NAME"]}#{route}"
+        else
+          env["sinatra.route"]
+        end
+      end
+
+      private
+
+      def raise_errors?(app)
+        app.respond_to?(:settings) &&
+          app.settings.respond_to?(:raise_errors) &&
+          app.settings.raise_errors
+      end
+    end
+  end
+end

data/lib/appsignal/rack/streaming_listener.rb

@@ -0,0 +1,73 @@
+module Appsignal
+  module Rack
+    # Appsignal module that tracks exceptions in Streaming rack responses.
+    #
+    # @api private
+    class StreamingListener
+      def initialize(app, options = {})
+        Appsignal.logger.debug "Initializing Appsignal::Rack::StreamingListener"
+        @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
+        )
+
+        # Instrument a `process_action`, to set params/action name
+        status, headers, body =
+          Appsignal.instrument("process_action.rack") do
+            begin
+              @app.call(env)
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              transaction.set_error(e)
+              raise e
+            ensure
+              transaction.set_action_if_nil(env["appsignal.action"])
+              transaction.set_metadata("path", request.path)
+              transaction.set_metadata("method", request.request_method)
+              transaction.set_http_or_background_queue_start
+            end
+          end
+
+        # Wrap the result body with our StreamWrapper
+        [status, headers, StreamWrapper.new(body, transaction)]
+      end
+    end
+  end
+
+  class StreamWrapper
+    def initialize(stream, transaction)
+      @stream = stream
+      @transaction = transaction
+    end
+
+    def each
+      @stream.each { |c| yield(c) }
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      @transaction.set_error(e)
+      raise e
+    end
+
+    def close
+      @stream.close if @stream.respond_to?(:close)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      @transaction.set_error(e)
+      raise e
+    ensure
+      Appsignal::Transaction.complete_current!
+    end
+  end
+end

data/lib/appsignal/system.rb

@@ -0,0 +1,81 @@
+module Appsignal
+  # System environment detection module.
+  #
+  # Provides useful methods to find out more about the host system.
+  #
+  # @api private
+  module System
+    MUSL_TARGET = "linux-musl".freeze
+    GEM_EXT_PATH = File.expand_path("../../../ext", __FILE__).freeze
+
+    def self.heroku?
+      ENV.key? "DYNO".freeze
+    end
+
+    # Returns the architecture for which the agent was installed.
+    #
+    # This value is saved when the gem is installed in `ext/extconf.rb`.
+    # We use this value to build the diagnose report with the installed
+    # CPU type and platform, rather than the detected architecture in
+    # {.agent_platform} during the diagnose run.
+    #
+    # @api private
+    # @return [String]
+    def self.installed_agent_architecture
+      architecture_file = File.join(GEM_EXT_PATH, "appsignal.architecture")
+      return unless File.exist?(architecture_file)
+      File.read(architecture_file)
+    end
+
+    # Detect agent and extension platform build
+    #
+    # Used by `ext/extconf.rb` to select which build it should download and
+    # install.
+    #
+    # Use `export APPSIGNAL_BUILD_FOR_MUSL=1` if the detection doesn't work
+    # and to force selection of the musl build.
+    #
+    # @api private
+    # @return [String]
+    def self.agent_platform
+      return MUSL_TARGET if ENV["APPSIGNAL_BUILD_FOR_MUSL"]
+
+      host_os = RbConfig::CONFIG["host_os"].downcase
+      local_os =
+        case host_os
+        when /linux/
+          "linux"
+        when /darwin/
+          "darwin"
+        when /freebsd/
+          "freebsd"
+        else
+          host_os
+        end
+      if local_os =~ /linux/
+        ldd_output = ldd_version_output
+        return MUSL_TARGET if ldd_output.include? "musl"
+        ldd_version = ldd_output.match(/\d+\.\d+/)
+        if ldd_version && versionify(ldd_version[0]) < versionify("2.15")
+          return MUSL_TARGET
+        end
+      end
+
+      local_os
+    end
+
+    # @api private
+    def self.versionify(version)
+      Gem::Version.new(version)
+    end
+
+    # @api private
+    def self.ldd_version_output
+      `ldd --version 2>&1`
+    end
+
+    def self.jruby?
+      RUBY_PLATFORM == "java"
+    end
+  end
+end

data/lib/appsignal/transaction.rb

@@ -0,0 +1,498 @@
+require "json"
+
+module Appsignal
+  class Transaction
+    HTTP_REQUEST   = "http_request".freeze
+    BACKGROUND_JOB = "background_job".freeze
+    ACTION_CABLE   = "action_cable".freeze
+    FRONTEND       = "frontend".freeze
+    BLANK          = "".freeze
+
+    # Based on what Rails uses + some variables we'd like to show
+    ENV_METHODS = %w[
+      CONTENT_LENGTH AUTH_TYPE GATEWAY_INTERFACE
+      PATH_TRANSLATED REMOTE_HOST REMOTE_IDENT REMOTE_USER REMOTE_ADDR
+      REQUEST_METHOD SERVER_NAME SERVER_PORT SERVER_PROTOCOL REQUEST_URI
+      PATH_INFO
+
+      HTTP_X_REQUEST_START HTTP_X_MIDDLEWARE_START HTTP_X_QUEUE_START
+      HTTP_X_QUEUE_TIME HTTP_X_HEROKU_QUEUE_WAIT_TIME HTTP_X_APPLICATION_START
+      HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING HTTP_ACCEPT_LANGUAGE
+      HTTP_CACHE_CONTROL HTTP_CONNECTION HTTP_USER_AGENT HTTP_FROM
+      HTTP_NEGOTIATE HTTP_PRAGMA HTTP_REFERER HTTP_X_FORWARDED_FOR
+      HTTP_CLIENT_IP HTTP_RANGE
+    ].freeze
+
+    class << self
+      def create(id, namespace, request, options = {})
+        # Allow middleware to force a new transaction
+        if options.include?(:force) && options[:force]
+          Thread.current[:appsignal_transaction] = nil
+        end
+
+        # Check if we already have a running transaction
+        if Thread.current[:appsignal_transaction] != nil
+          # Log the issue and return the current transaction
+          Appsignal.logger.debug "Trying to start new transaction with id " \
+            "'#{id}', but a transaction with id '#{current.transaction_id}' " \
+            "is already running. Using transaction '#{current.transaction_id}'."
+
+          # Return the current (running) transaction
+          current
+        else
+          # Otherwise, start a new transaction
+          Thread.current[:appsignal_transaction] = Appsignal::Transaction.new(id, namespace, request, options)
+        end
+      end
+
+      def current
+        Thread.current[:appsignal_transaction] || NilTransaction.new
+      end
+
+      def complete_current!
+        current.complete
+      rescue => e
+        Appsignal.logger.error("Failed to complete transaction ##{current.transaction_id}. #{e.message}")
+      ensure
+        clear_current_transaction!
+      end
+
+      # Remove current transaction from current Thread.
+      # @api private
+      def clear_current_transaction!
+        Thread.current[:appsignal_transaction] = nil
+      end
+
+      def garbage_collection_profiler
+        @garbage_collection_profiler ||= Appsignal::GarbageCollectionProfiler.new
+      end
+    end
+
+    attr_reader :ext, :transaction_id, :action, :namespace, :request, :paused, :tags, :options, :discarded
+
+    # @!attribute params
+    #   Attribute for parameters of the transaction.
+    #
+    #   When no parameters are set with {#params=} the parameters it will look
+    #   for parameters on the {#request} environment.
+    #
+    #   The parameters set using {#params=} are leading over those extracted
+    #   from a request's environment.
+    #
+    #   @return [Hash]
+    attr_writer :params
+
+    def initialize(transaction_id, namespace, request, options = {})
+      @transaction_id = transaction_id
+      @action = nil
+      @namespace = namespace
+      @request = request
+      @paused = false
+      @discarded = false
+      @tags = {}
+      @store = Hash.new({})
+      @options = options
+      @options[:params_method] ||= :params
+
+      @ext = Appsignal::Extension.start_transaction(
+        @transaction_id,
+        @namespace,
+        self.class.garbage_collection_profiler.total_time
+      )
+    end
+
+    def nil_transaction?
+      false
+    end
+
+    def complete
+      if discarded?
+        Appsignal.logger.debug "Skipping transaction '#{transaction_id}' " \
+          "because it was manually discarded."
+        return
+      end
+      if @ext.finish(self.class.garbage_collection_profiler.total_time)
+        sample_data
+      end
+      @ext.complete
+    end
+
+    def pause!
+      @paused = true
+    end
+
+    def resume!
+      @paused = false
+    end
+
+    def paused?
+      @paused == true
+    end
+
+    def discard!
+      @discarded = true
+    end
+
+    def restore!
+      @discarded = false
+    end
+
+    def discarded?
+      @discarded == true
+    end
+
+    def store(key)
+      @store[key]
+    end
+
+    def params
+      return @params if defined?(@params)
+      request_params
+    end
+
+    # Set tags on the transaction.
+    #
+    # @param given_tags [Hash] Collection of tags.
+    # @option given_tags [String, Symbol, Integer] :any
+    #   The name of the tag as a Symbol.
+    # @option given_tags [String, Symbol, Integer] "any"
+    #   The name of the tag as a String.
+    # @return [void]
+    #
+    # @see Appsignal.tag_request
+    # @see http://docs.appsignal.com/ruby/instrumentation/tagging.html
+    #   Tagging guide
+    def set_tags(given_tags = {})
+      @tags.merge!(given_tags)
+    end
+
+    # Set an action name for the transaction.
+    #
+    # An action name is used to identify the location of a certain sample;
+    # error and performance issues.
+    #
+    # @param action [String] the action name to set.
+    # @return [void]
+    # @see Appsignal.set_action
+    # @see #set_action_if_nil
+    # @since 2.2.0
+    def set_action(action)
+      return unless action
+      @action = action
+      @ext.set_action(action)
+    end
+
+    # Set an action name only if there is no current action set.
+    #
+    # Commonly used by AppSignal integrations so that they don't override
+    # custom action names.
+    #
+    # @example
+    #   Appsignal.set_action("foo")
+    #   Appsignal.set_action_if_nil("bar")
+    #   # Transaction action will be "foo"
+    #
+    # @param action [String]
+    # @return [void]
+    # @see #set_action
+    # @since 2.2.0
+    def set_action_if_nil(action)
+      return if @action
+      set_action(action)
+    end
+
+    # Set the namespace for this transaction.
+    #
+    # Useful to split up parts of an application into certain namespaces. For
+    # example: http requests, background jobs and administration panel
+    # controllers.
+    #
+    # Note: The "http_request" namespace gets transformed on AppSignal.com to
+    # "Web" and "background_job" gets transformed to "Background".
+    #
+    # @example
+    #   transaction.set_action("admin")
+    #
+    # @param namespace [String] namespace name to use for this transaction.
+    # @return [void]
+    # @since 2.2.0
+    def set_namespace(namespace)
+      return unless namespace
+      @namespace = namespace
+      @ext.set_namespace(namespace)
+    end
+
+    def set_http_or_background_action(from = request.params)
+      return unless from
+      group_and_action = [
+        from[:controller] || from[:class],
+        from[:action] || from[:method]
+      ]
+      set_action(group_and_action.compact.join("#"))
+    end
+
+    def set_queue_start(start)
+      return unless start
+      @ext.set_queue_start(start)
+    rescue RangeError
+      Appsignal.logger.warn("Queue start value #{start} is too big")
+    end
+
+    def set_http_or_background_queue_start
+      if namespace == HTTP_REQUEST
+        set_queue_start(http_queue_start)
+      elsif namespace == BACKGROUND_JOB
+        set_queue_start(background_queue_start)
+      end
+    end
+
+    def set_metadata(key, value)
+      return unless key && value
+      @ext.set_metadata(key, value)
+    end
+
+    def set_sample_data(key, data)
+      return unless key && data && (data.is_a?(Array) || data.is_a?(Hash))
+      @ext.set_sample_data(
+        key.to_s,
+        Appsignal::Utils.data_generate(data)
+      )
+    rescue RuntimeError => e
+      Appsignal.logger.error("Error generating data (#{e.class}: #{e.message}) for '#{data.inspect}'")
+    end
+
+    def sample_data
+      {
+        :params       => sanitized_params,
+        :environment  => sanitized_environment,
+        :session_data => sanitized_session_data,
+        :metadata     => metadata,
+        :tags         => sanitized_tags
+      }.each do |key, data|
+        set_sample_data(key, data)
+      end
+    end
+
+    def set_error(error)
+      return unless error
+      return unless Appsignal.active?
+
+      backtrace = cleaned_backtrace(error.backtrace)
+      @ext.set_error(
+        error.class.name,
+        error.message.to_s,
+        backtrace ? Appsignal::Utils.data_generate(backtrace) : Appsignal::Extension.data_array_new
+      )
+    end
+    alias_method :add_exception, :set_error
+
+    def start_event
+      @ext.start_event(self.class.garbage_collection_profiler.total_time)
+    end
+
+    def finish_event(name, title, body, body_format = Appsignal::EventFormatter::DEFAULT)
+      @ext.finish_event(
+        name,
+        title || BLANK,
+        body || BLANK,
+        body_format || Appsignal::EventFormatter::DEFAULT,
+        self.class.garbage_collection_profiler.total_time
+      )
+    end
+
+    def record_event(name, title, body, duration, body_format = Appsignal::EventFormatter::DEFAULT)
+      @ext.record_event(
+        name,
+        title || BLANK,
+        body || BLANK,
+        body_format || Appsignal::EventFormatter::DEFAULT,
+        duration,
+        self.class.garbage_collection_profiler.total_time
+      )
+    end
+
+    def instrument(name, title = nil, body = nil, body_format = Appsignal::EventFormatter::DEFAULT)
+      start_event
+      yield if block_given?
+    ensure
+      finish_event(name, title, body, body_format)
+    end
+
+    # @api private
+    def to_h
+      JSON.parse(@ext.to_json)
+    end
+    alias_method :to_hash, :to_h
+
+    class GenericRequest
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      def params
+        env[:params]
+      end
+    end
+
+    private
+
+    # Returns calculated background queue start time in milliseconds, based on
+    # environment values.
+    #
+    # @return [nil] if no {#environment} is present.
+    # @return [nil] if there is no `:queue_start` in the {#environment}.
+    # @return [Integer]
+    def background_queue_start
+      env = environment
+      return unless env
+      queue_start = env[:queue_start]
+      return unless queue_start
+
+      (queue_start.to_f * 1000.0).to_i
+    end
+
+    # Returns HTTP queue start time in milliseconds.
+    #
+    # @return [nil] if no queue start time is found.
+    # @return [nil] if begin time is too low to be plausible.
+    # @return [Integer] queue start in milliseconds.
+    def http_queue_start
+      env = environment
+      return unless env
+      env_var = env["HTTP_X_QUEUE_START".freeze] || env["HTTP_X_REQUEST_START".freeze]
+      return unless env_var
+      cleaned_value = env_var.tr("^0-9".freeze, "".freeze)
+      return if cleaned_value.empty?
+
+      value = cleaned_value.to_i
+      if value > 4_102_441_200_000
+        # Value is in microseconds. Transform to milliseconds.
+        value / 1_000
+      elsif value < 946_681_200_000
+        # Value is too low to be plausible
+        nil
+      else
+        # Value is in milliseconds
+        value
+      end
+    end
+
+    def sanitized_params
+      return unless Appsignal.config[:send_params]
+
+      options = {}
+      if Appsignal.config[:filter_parameters]
+        options[:filter_parameters] = Appsignal.config[:filter_parameters]
+      end
+      Appsignal::Utils::ParamsSanitizer.sanitize params, options
+    end
+
+    def request_params
+      return unless request.respond_to?(options[:params_method])
+
+      begin
+        request.send options[:params_method]
+      rescue => e
+        # Getting params from the request has been know to fail.
+        Appsignal.logger.debug "Exception while getting params: #{e}"
+        nil
+      end
+    end
+
+    # Returns sanitized environment for a transaction.
+    #
+    # The environment of a transaction can contain a lot of information, not
+    # all of it useful for debugging.
+    #
+    # Only the values from the keys specified in {ENV_METHODS} are returned.
+    #
+    # @return [nil] if no environment is present.
+    # @return [Hash<String, Object>]
+    def sanitized_environment
+      env = environment
+      return if env.empty?
+
+      {}.tap do |out|
+        ENV_METHODS.each do |key|
+          out[key] = env[key] if env[key]
+        end
+      end
+    end
+
+    # Returns sanitized session data.
+    #
+    # The session data is sanitized by the {Appsignal::Utils::ParamsSanitizer}.
+    #
+    # @return [nil] if `:skip_session_data` config is set to `true`.
+    # @return [nil] if the {#request} object doesn't respond to `#session`.
+    # @return [nil] if the {#request} session data is `nil`.
+    # @return [Hash<String, Object>]
+    def sanitized_session_data
+      return if Appsignal.config[:skip_session_data] ||
+          !request.respond_to?(:session)
+      session = request.session
+      return unless session
+
+      Appsignal::Utils::ParamsSanitizer.sanitize(session.to_hash)
+    end
+
+    # Returns metadata from the environment.
+    #
+    # @return [nil] if no `:metadata` key is present in the {#environment}.
+    # @return [Hash<String, Object>]
+    def metadata
+      environment[:metadata]
+    end
+
+    # Returns the environment for a transaction.
+    #
+    # Returns an empty Hash when the {#request} object doesn't listen to the
+    # `#env` method or the `#env` is nil.
+    #
+    # @return [Hash<String, Object>]
+    def environment
+      return {} unless request.respond_to?(:env)
+      return {} unless request.env
+
+      request.env
+    end
+
+    # Only keep tags if they meet the following criteria:
+    # * Key is a symbol or string with less then 100 chars
+    # * Value is a symbol or string with less then 100 chars
+    # * Value is an integer
+    def sanitized_tags
+      @tags.select do |k, v|
+        (k.is_a?(Symbol) || k.is_a?(String) && k.length <= 100) &&
+          (((v.is_a?(Symbol) || v.is_a?(String)) && v.length <= 100) || v.is_a?(Integer))
+      end
+    end
+
+    def cleaned_backtrace(backtrace)
+      if defined?(::Rails) && backtrace
+        ::Rails.backtrace_cleaner.clean(backtrace, nil)
+      else
+        backtrace
+      end
+    end
+
+    # Stub that is returned by {Transaction.current} if there is no current
+    # transaction, so that it's still safe to call methods on it if there is no
+    # current transaction.
+    class NilTransaction
+      def method_missing(m, *args, &block)
+      end
+
+      # Instrument should still yield
+      def instrument(*_args)
+        yield
+      end
+
+      def nil_transaction?
+        true
+      end
+    end
+  end
+end