appsignal 2.5.0.alpha.1-java

data/lib/appsignal/event_formatter/action_view/render_formatter.rb

@@ -0,0 +1,24 @@
+module Appsignal
+  class EventFormatter
+    # @api private
+    module ActionView
+      class RenderFormatter < Appsignal::EventFormatter
+        register "render_partial.action_view"
+        register "render_template.action_view"
+
+        BLANK = "".freeze
+
+        attr_reader :root_path
+
+        def initialize
+          @root_path = "#{Rails.root}/".freeze
+        end
+
+        def format(payload)
+          return nil unless payload[:identifier]
+          [payload[:identifier].sub(root_path, BLANK), nil]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/active_record/instantiation_formatter.rb

@@ -0,0 +1,14 @@
+module Appsignal
+  class EventFormatter
+    # @api private
+    module ActiveRecord
+      class InstantiationFormatter < Appsignal::EventFormatter
+        register "instantiation.active_record"
+
+        def format(payload)
+          [payload[:class_name], nil]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/active_record/sql_formatter.rb

@@ -0,0 +1,14 @@
+module Appsignal
+  class EventFormatter
+    # @api private
+    module ActiveRecord
+      class SqlFormatter < Appsignal::EventFormatter
+        register "sql.active_record"
+
+        def format(payload)
+          [payload[:name], payload[:sql], SQL_BODY_FORMAT]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/elastic_search/search_formatter.rb

@@ -0,0 +1,32 @@
+module Appsignal
+  class EventFormatter
+    # @api private
+    module ElasticSearch
+      class SearchFormatter < Appsignal::EventFormatter
+        register "search.elasticsearch"
+
+        def format(payload)
+          [
+            "#{payload[:name]}: #{payload[:klass]}",
+            sanitized_search(payload[:search]).inspect
+          ]
+        end
+
+        def sanitized_search(search)
+          return unless search.is_a?(Hash)
+
+          {}.tap do |hsh|
+            search.each do |key, val|
+              hsh[key] =
+                if [:index, :type].include?(key)
+                  val
+                else
+                  Appsignal::Utils::QueryParamsSanitizer.sanitize(val)
+                end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/faraday/request_formatter.rb

@@ -0,0 +1,19 @@
+module Appsignal
+  class EventFormatter
+    # @api private
+    module Faraday
+      class RequestFormatter < Appsignal::EventFormatter
+        register "request.faraday"
+
+        def format(payload)
+          http_method = payload[:method].to_s.upcase
+          uri = payload[:url]
+          [
+            "#{http_method} #{uri.scheme}://#{uri.host}",
+            "#{http_method} #{uri.scheme}://#{uri.host}#{uri.path}"
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/mongo_ruby_driver/query_formatter.rb

@@ -0,0 +1,89 @@
+module Appsignal
+  class EventFormatter
+    # @api private
+    module MongoRubyDriver
+      class QueryFormatter
+        ALLOWED = {
+          "find" => {
+            "find"   => :allow,
+            "filter" => :sanitize_document
+          },
+          "count" => {
+            "count" => :allow,
+            "query" => :sanitize_document
+          },
+          "distinct" => {
+            "distinct" => :allow,
+            "key"      => :allow,
+            "query"    => :sanitize_document
+          },
+          "insert" => {
+            "insert"    => :allow,
+            "documents" => :deny_array,
+            "ordered"   => :allow
+          },
+          "update" => {
+            "update"  => :allow,
+            "updates" => :sanitize_bulk,
+            "ordered" => :allow
+          },
+          "findandmodify" => {
+            "findandmodify" => :allow,
+            "query"         => :sanitize_document,
+            "update"        => :deny_array,
+            "new"           => :allow
+          },
+          "delete" => {
+            "delete" => :allow,
+            "deletes" => :sanitize_bulk,
+            "ordered" => :allow
+          },
+          "bulk" => {
+            "q"      => :sanitize_document,
+            "u"      => :deny_array,
+            "limit"  => :allow,
+            "multi"  => :allow,
+            "upsert" => :allow
+          }
+        }.freeze
+
+        # Format command based on given strategy
+        def self.format(strategy, command)
+          # Stop processing if command is not a hash
+          return {} unless command.is_a?(Hash)
+
+          # Get the strategy and stop if it's not present
+          strategies = ALLOWED[strategy.to_s]
+          return {} unless strategies
+
+          {}.tap do |hsh|
+            command.each do |key, val|
+              hsh[key] = apply_strategy(strategies[key], val)
+            end
+          end
+        end
+
+        # Applies strategy on hash values based on keys
+        def self.apply_strategy(strategy, val)
+          case strategy
+          when :allow      then val
+          when :deny       then "?"
+          when :deny_array then "[?]"
+          when :sanitize_document
+            Appsignal::Utils::QueryParamsSanitizer.sanitize(val, true, :mongodb)
+          when :sanitize_bulk
+            if val.length > 1
+              [
+                format(:bulk, val.first),
+                "[...]"
+              ]
+            else
+              val.map { |v| format(:bulk, v) }
+            end
+          else "?"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/moped/query_formatter.rb

@@ -0,0 +1,80 @@
+module Appsignal
+  class EventFormatter
+    # @api private
+    module Moped
+      class QueryFormatter < Appsignal::EventFormatter
+        register "query.moped"
+
+        def format(payload)
+          if payload[:ops] && !payload[:ops].empty?
+            op = payload[:ops].first
+            case op.class.to_s
+            when "Moped::Protocol::Command"
+              [
+                "Command", {
+                  :database => op.full_collection_name,
+                  :selector => sanitize(op.selector, true, :mongodb)
+                }.inspect
+              ]
+            when "Moped::Protocol::Query"
+              [
+                "Query", {
+                  :database => op.full_collection_name,
+                  :selector => sanitize(op.selector, false, :mongodb),
+                  :flags    => op.flags,
+                  :limit    => op.limit,
+                  :skip     => op.skip,
+                  :fields   => op.fields
+                }.inspect
+              ]
+            when "Moped::Protocol::Delete"
+              [
+                "Delete", {
+                  :database => op.full_collection_name,
+                  :selector => sanitize(op.selector, false, :mongodb),
+                  :flags    => op.flags
+                }.inspect
+              ]
+            when "Moped::Protocol::Insert"
+              [
+                "Insert", {
+                  :database   => op.full_collection_name,
+                  :documents  => sanitize(op.documents, true, :mongodb),
+                  :count      => op.documents.count,
+                  :flags      => op.flags
+                }.inspect
+              ]
+            when "Moped::Protocol::Update"
+              [
+                "Update",
+                {
+                  :database => op.full_collection_name,
+                  :selector => sanitize(op.selector, false, :mongodb),
+                  :update   => sanitize(op.update, true, :mongodb),
+                  :flags    => op.flags
+                }.inspect
+              ]
+            when "Moped::Protocol::KillCursors"
+              [
+                "KillCursors",
+                { :number_of_cursor_ids => op.number_of_cursor_ids }.inspect
+              ]
+            else
+              [
+                op.class.to_s.sub("Moped::Protocol::", ""),
+                { :database => op.full_collection_name }.inspect
+              ]
+            end
+          end
+        end
+
+        private
+
+        def sanitize(params, only_top_level, key_sanitizer)
+          Appsignal::Utils::QueryParamsSanitizer.sanitize \
+            params, only_top_level, key_sanitizer
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/extension.rb

@@ -0,0 +1,63 @@
+require "yaml"
+
+begin
+  if Appsignal::System.jruby?
+    require "appsignal/extension/jruby"
+    # {Appsignal.extension_loaded} is set in the jRuby extension file
+  else
+    require "appsignal_extension"
+    Appsignal.extension_loaded = true
+  end
+rescue LoadError => err
+  Appsignal.logger.error(
+    "Failed to load extension (#{err}), please check the install.log file in " \
+    "the ext directory of the gem and email us at support@appsignal.com"
+  )
+  Appsignal.extension_loaded = false
+end
+
+module Appsignal
+  # @api private
+  class Extension
+    class << self
+      def agent_config
+        @agent_config ||= YAML.load(
+          File.read(File.join(File.dirname(__FILE__), "../../ext/agent.yml"))
+        )
+      end
+
+      def agent_version
+        agent_config["version"]
+      end
+
+      # Do nothing if the extension methods are not loaded
+      #
+      # Disabled in testing so we can make sure that we don't miss a extension
+      # function implementation.
+      def method_missing(m, *args, &block)
+        super if Appsignal.testing?
+      end
+    end
+
+    if Appsignal::System.jruby?
+      extend Appsignal::Extension::Jruby
+
+      # Reassign Transaction class for jRuby extension usage.
+      #
+      # Makes sure the generated docs aren't always overwritten with the jRuby
+      # version.
+      Transaction = Jruby::Transaction
+      # Reassign Data class for jRuby extension usage.
+      #
+      # Makes sure the generated docs aren't always overwritten with the jRuby
+      # version.
+      Data = Jruby::Data
+    end
+
+    class Data
+      def inspect
+        "#<#{self.class.name}:#{object_id} #{self}>"
+      end
+    end
+  end
+end

data/lib/appsignal/extension/jruby.rb

@@ -0,0 +1,460 @@
+require "ffi"
+
+module Appsignal
+  class Extension
+    # jRuby extension wrapper
+    #
+    # Only loaded if the system is detected as jRuby.
+    #
+    # @api private
+    module Jruby # rubocop:disable Metrics/ModuleLength
+      extend FFI::Library
+
+      # jRuby extension String helpers.
+      #
+      # Based on the make_appsignal_string and make_ruby_string helpers from the
+      # AppSignal C-extension in `ext/appsignal_extension.c`.
+      module StringHelpers
+        class AppsignalString < FFI::Struct
+          layout :len, :size_t,
+            :buf, :pointer
+        end
+
+        def make_appsignal_string(ruby_string)
+          unless ruby_string.is_a?(String)
+            raise ArgumentError, "argument is not a string"
+          end
+
+          AppsignalString.new.tap do |appsignal_string|
+            appsignal_string[:len] = ruby_string.bytesize
+            appsignal_string[:buf] = FFI::MemoryPointer.from_string(ruby_string)
+          end
+        end
+
+        def make_ruby_string(appsignal_string)
+          appsignal_string[:buf].read_string(appsignal_string[:len]).tap do |ruby_string|
+            ruby_string.force_encoding(Encoding::UTF_8)
+          end
+        end
+      end
+      include StringHelpers
+
+      def self.lib_extension
+        if Appsignal::System.agent_platform.include?("darwin")
+          "dylib"
+        else
+          "so"
+        end
+      end
+
+      begin
+        ffi_lib File.join(File.dirname(__FILE__), "../../../ext/libappsignal.#{lib_extension}")
+        typedef AppsignalString.by_value, :appsignal_string
+
+        attach_function :appsignal_start, [], :void
+        attach_function :appsignal_stop, [], :void
+        attach_function :appsignal_diagnose, [], :appsignal_string
+        attach_function :appsignal_get_server_state,
+          [:appsignal_string],
+          :appsignal_string
+        attach_function :appsignal_running_in_container, [], :bool
+
+        # Metrics methods
+        attach_function :appsignal_set_gauge,
+          [:appsignal_string, :double],
+          :void
+        attach_function :appsignal_set_host_gauge,
+          [:appsignal_string, :double],
+          :void
+        attach_function :appsignal_set_process_gauge,
+          [:appsignal_string, :double],
+          :void
+        attach_function :appsignal_increment_counter,
+          [:appsignal_string, :int64],
+          :void
+        attach_function :appsignal_add_distribution_value,
+          [:appsignal_string, :double],
+          :void
+
+        # Transaction methods
+        attach_function :appsignal_free_transaction,
+          [],
+          :void
+        attach_function :appsignal_start_transaction,
+          [:appsignal_string, :appsignal_string, :long],
+          :pointer
+        attach_function :appsignal_start_event,
+          [:pointer, :long],
+          :void
+        attach_function :appsignal_finish_event,
+          [:pointer, :appsignal_string, :appsignal_string, :appsignal_string, :int64, :long],
+          :void
+        attach_function :appsignal_finish_event_data,
+          [:pointer, :appsignal_string, :appsignal_string, :pointer, :int64, :long],
+          :void
+        attach_function :appsignal_record_event,
+          [:pointer, :appsignal_string, :appsignal_string, :appsignal_string, :int64, :long, :long],
+          :void
+        attach_function :appsignal_record_event_data,
+          [:pointer, :appsignal_string, :appsignal_string, :pointer, :int64, :long, :long],
+          :void
+        attach_function :appsignal_set_transaction_error,
+          [:pointer, :appsignal_string, :appsignal_string, :pointer],
+          :void
+        attach_function :appsignal_set_transaction_action,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_set_transaction_namespace,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_set_transaction_sample_data,
+          [:pointer, :appsignal_string, :pointer],
+          :void
+        attach_function :appsignal_set_transaction_queue_start,
+          [:pointer, :long],
+          :void
+        attach_function :appsignal_set_transaction_metadata,
+          [:pointer, :appsignal_string, :appsignal_string],
+          :void
+        attach_function :appsignal_finish_transaction,
+          [:pointer, :long],
+          :void
+        attach_function :appsignal_complete_transaction,
+          [:pointer],
+          :void
+        attach_function :appsignal_transaction_to_json,
+          [:pointer],
+          :appsignal_string
+
+        # Data struct methods
+        attach_function :appsignal_free_data, [], :void
+        attach_function :appsignal_data_map_new, [], :pointer
+        attach_function :appsignal_data_array_new, [], :pointer
+        attach_function :appsignal_data_map_set_string,
+          [:pointer, :appsignal_string, :appsignal_string],
+          :void
+        attach_function :appsignal_data_map_set_integer,
+          [:pointer, :appsignal_string, :int64],
+          :void
+        attach_function :appsignal_data_map_set_float,
+          [:pointer, :appsignal_string, :double],
+          :void
+        attach_function :appsignal_data_map_set_boolean,
+          [:pointer, :appsignal_string, :bool],
+          :void
+        attach_function :appsignal_data_map_set_null,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_data_map_set_data,
+          [:pointer, :appsignal_string, :pointer],
+          :void
+        attach_function :appsignal_data_array_append_string,
+          [:pointer, :appsignal_string],
+          :void
+        attach_function :appsignal_data_array_append_integer,
+          [:pointer, :int64],
+          :void
+        attach_function :appsignal_data_array_append_float,
+          [:pointer, :double],
+          :void
+        attach_function :appsignal_data_array_append_boolean,
+          [:pointer, :bool],
+          :void
+        attach_function :appsignal_data_array_append_null,
+          [:pointer],
+          :void
+        attach_function :appsignal_data_array_append_data,
+          [:pointer, :pointer],
+          :void
+        attach_function :appsignal_data_equal,
+          [:pointer, :pointer],
+          :bool
+        attach_function :appsignal_data_to_json,
+          [:pointer],
+          :appsignal_string
+
+        Appsignal.extension_loaded = true
+      rescue LoadError => err
+        Appsignal.logger.error(
+          "Failed to load extension (#{err}), please email us at " \
+          "support@appsignal.com"
+        )
+        Appsignal.extension_loaded = false
+      end
+
+      def start
+        appsignal_start
+      end
+
+      def stop
+        appsignal_stop
+      end
+
+      def diagnose
+        make_ruby_string(appsignal_diagnose)
+      end
+
+      def get_server_state(key)
+        state = appsignal_get_server_state(make_appsignal_string(key))
+        make_ruby_string state if state[:len] > 0
+      end
+
+      def start_transaction(transaction_id, namespace, gc_duration_ms)
+        transaction = appsignal_start_transaction(
+          make_appsignal_string(transaction_id),
+          make_appsignal_string(namespace),
+          gc_duration_ms
+        )
+
+        return if !transaction || transaction.null?
+        Transaction.new(transaction)
+      end
+
+      def data_map_new
+        Data.new(appsignal_data_map_new)
+      end
+
+      def data_array_new
+        Data.new(appsignal_data_array_new)
+      end
+
+      def running_in_container?
+        appsignal_running_in_container
+      end
+
+      def set_gauge(key, value)
+        appsignal_set_gauge(make_appsignal_string(key), value)
+      end
+
+      def set_host_gauge(key, value)
+        appsignal_set_host_gauge(make_appsignal_string(key), value)
+      end
+
+      def set_process_gauge(key, value)
+        appsignal_set_process_gauge(make_appsignal_string(key), value)
+      end
+
+      def increment_counter(key, value)
+        appsignal_increment_counter(make_appsignal_string(key), value)
+      end
+
+      def add_distribution_value(key, value)
+        appsignal_add_distribution_value(make_appsignal_string(key), value)
+      end
+
+      class Transaction # rubocop:disable Metrics/ClassLength
+        include StringHelpers
+
+        attr_reader :pointer
+
+        def initialize(pointer)
+          @pointer = FFI::AutoPointer.new(
+            pointer,
+            Extension.method(:appsignal_free_transaction)
+          )
+        end
+
+        def start_event(gc_duration_ms)
+          Extension.appsignal_start_event(pointer, gc_duration_ms)
+        end
+
+        def finish_event(name, title, body, body_format, gc_duration_ms)
+          case body
+          when String
+            method = :appsignal_finish_event
+            body_arg = make_appsignal_string(body)
+          when Data
+            method = :appsignal_finish_event_data
+            body_arg = body.pointer
+          else
+            raise ArgumentError,
+              "body argument should be a String or Appsignal::Extension::Data"
+          end
+          Extension.public_send(
+            method,
+            pointer,
+            make_appsignal_string(name),
+            make_appsignal_string(title),
+            body_arg,
+            body_format,
+            gc_duration_ms
+          )
+        end
+
+        def record_event(name, title, body, body_format, duration, gc_duration_ms) # rubocop:disable Metrics/ParameterLists
+          case body
+          when String
+            method = :appsignal_record_event
+            body_arg = make_appsignal_string(body)
+          when Data
+            method = :appsignal_record_event_data
+            body_arg = body.pointer
+          else
+            raise ArgumentError,
+              "body argument should be a String or Appsignal::Extension::Data"
+          end
+          Extension.public_send(
+            method,
+            pointer,
+            make_appsignal_string(name),
+            make_appsignal_string(title),
+            body_arg,
+            body_format,
+            duration,
+            gc_duration_ms
+          )
+        end
+
+        def set_error(name, message, backtrace)
+          Extension.appsignal_set_transaction_error(
+            pointer,
+            make_appsignal_string(name),
+            make_appsignal_string(message),
+            backtrace.pointer
+          )
+        end
+
+        def set_action(action_name) # rubocop:disable Style/AccessorMethodName
+          Extension.appsignal_set_transaction_action(
+            pointer,
+            make_appsignal_string(action_name)
+          )
+        end
+
+        def set_namespace(namespace) # rubocop:disable Style/AccessorMethodName
+          Extension.appsignal_set_transaction_namespace(
+            pointer,
+            make_appsignal_string(namespace)
+          )
+        end
+
+        def set_sample_data(key, payload)
+          Extension.appsignal_set_transaction_sample_data(
+            pointer,
+            make_appsignal_string(key),
+            payload.pointer
+          )
+        end
+
+        def set_queue_start(time) # rubocop:disable Style/AccessorMethodName
+          Extension.appsignal_set_transaction_queue_start(pointer, time)
+        end
+
+        def set_metadata(key, value)
+          Extension.appsignal_set_transaction_metadata(
+            pointer,
+            make_appsignal_string(key),
+            make_appsignal_string(value)
+          )
+        end
+
+        def finish(gc_duration_ms)
+          Extension.appsignal_finish_transaction(pointer, gc_duration_ms)
+        end
+
+        def complete
+          Extension.appsignal_complete_transaction(pointer)
+        end
+
+        def to_json
+          json = Extension.appsignal_transaction_to_json(pointer)
+          make_ruby_string(json) if json[:len] > 0
+        end
+      end
+
+      class Data
+        include StringHelpers
+        attr_reader :pointer
+
+        def initialize(pointer)
+          @pointer = FFI::AutoPointer.new(
+            pointer,
+            Extension.method(:appsignal_free_data)
+          )
+        end
+
+        def set_string(key, value)
+          Extension.appsignal_data_map_set_string(
+            pointer,
+            make_appsignal_string(key),
+            make_appsignal_string(value)
+          )
+        end
+
+        def set_integer(key, value)
+          Extension.appsignal_data_map_set_integer(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def set_float(key, value)
+          Extension.appsignal_data_map_set_float(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def set_boolean(key, value)
+          Extension.appsignal_data_map_set_boolean(
+            pointer,
+            make_appsignal_string(key),
+            value
+          )
+        end
+
+        def set_nil(key) # rubocop:disable Style/AccessorMethodName
+          Extension.appsignal_data_map_set_null(
+            pointer,
+            make_appsignal_string(key)
+          )
+        end
+
+        def set_data(key, value)
+          Extension.appsignal_data_map_set_data(
+            pointer,
+            make_appsignal_string(key),
+            value.pointer
+          )
+        end
+
+        def append_string(value)
+          Extension.appsignal_data_array_append_string(
+            pointer,
+            make_appsignal_string(value)
+          )
+        end
+
+        def append_integer(value)
+          Extension.appsignal_data_array_append_integer(pointer, value)
+        end
+
+        def append_float(value)
+          Extension.appsignal_data_array_append_float(pointer, value)
+        end
+
+        def append_boolean(value)
+          Extension.appsignal_data_array_append_boolean(pointer, value)
+        end
+
+        def append_nil
+          Extension.appsignal_data_array_append_null(pointer)
+        end
+
+        def append_data(value)
+          Extension.appsignal_data_array_append_data(pointer, value.pointer)
+        end
+
+        def ==(other)
+          Extension.appsignal_data_equal(pointer, other.pointer)
+        end
+
+        def to_s
+          make_ruby_string Extension.appsignal_data_to_json(pointer)
+        end
+      end
+    end
+  end
+end