elastic-apm 3.3.0 → 3.4.0

data/lib/elastic_apm/spies/shoryuken.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Spies
+    # @api private
+    class ShoryukenSpy
+      # @api private
+      class Middleware
+        def call(worker_instance, queue, sqs_msg, body)
+          transaction =
+            ElasticAPM.start_transaction(
+              job_class(worker_instance, body),
+              'shoryuken.job'
+            )
+
+          ElasticAPM.set_label('shoryuken.id', sqs_msg.message_id)
+          ElasticAPM.set_label('shoryuken.queue', queue)
+
+          yield
+
+          transaction&.done :success
+        rescue ::Exception => e
+          ElasticAPM.report(e, handled: false)
+          transaction&.done :error
+          raise
+        ensure
+          ElasticAPM.end_transaction
+        end
+
+        private
+
+        def job_class(worker_instance, body)
+          klass = body['job_class'] if body.is_a?(Hash)
+          klass || worker_instance.class.name
+        end
+      end
+
+      def install
+        ::Shoryuken.server_middleware do |chain|
+          chain.add Middleware
+        end
+      end
+    end
+
+    register 'Shoryuken', 'shoryuken', ShoryukenSpy.new
+  end
+end

data/lib/elastic_apm/spies/sneakers.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Spies
+    # @api private
+    class SneakersSpy
+      include Logging
+
+      def self.supported_version?
+        Gem.loaded_specs['sneakers'].version >= Gem::Version.create('2.12.0')
+      end
+
+      def install
+        unless SneakersSpy.supported_version?
+          warn(
+            'Sneakers version is below 2.12.0. Sneakers spy installation failed'
+          )
+          return
+        end
+
+        Sneakers.middleware.use(Middleware, nil)
+      end
+
+      # @api private
+      class Middleware
+        def initialize(app, *args)
+          @app = app
+          @args = args
+        end
+
+        def call(deserialized_msg, delivery_info, metadata, handler)
+          transaction =
+            ElasticAPM.start_transaction(
+              delivery_info.consumer.queue.name,
+              'Sneakers'
+            )
+
+          ElasticAPM.set_label(:routing_key, delivery_info.routing_key)
+
+          res = @app.call(deserialized_msg, delivery_info, metadata, handler)
+          transaction&.done(:success)
+
+          res
+        rescue ::Exception => e
+          ElasticAPM.report(e, handled: false)
+          transaction&.done(:error)
+          raise
+        ensure
+          ElasticAPM.end_transaction
+        end
+      end
+    end
+
+    register 'Sneakers', 'sneakers', SneakersSpy.new
+  end
+end

data/lib/elastic_apm/sql.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Sql
+    # This method is only here as a shortcut while the agent ships with
+    # both implementations ~mikker
+    def self.summarizer
+      @summarizer ||=
+        if ElasticAPM.agent&.config&.use_experimental_sql_parser
+          require 'elastic_apm/sql/signature'
+          Sql::Signature::Summarizer.new
+        else
+          require 'elastic_apm/sql_summarizer'
+          SqlSummarizer.new
+        end
+    end
+  end
+end

data/lib/elastic_apm/sql/signature.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/sql/tokenizer'
+
+module ElasticAPM
+  module Sql
+    # @api private
+    class Signature
+      include Tokens
+
+      # Mostly here to provide a similar API to new SqlSummarizer for easier
+      # swapping out
+      #
+      # @api private
+      class Summarizer
+        def summarize(sql)
+          Signature.parse(sql)
+        end
+      end
+
+      def initialize(sql)
+        @sql = sql
+        @tokenizer = Tokenizer.new(sql)
+      end
+
+      def parse
+        @tokenizer.scan # until tokenizer.token != COMMENT
+
+        parsed = parse_tokens
+        return parsed if parsed
+
+        # If all else fails, just return the first token of the query.
+        parts = @sql.split
+        return '' unless parts.any?
+
+        parts.first.upcase
+      end
+
+      def self.parse(sql)
+        new(sql).parse
+      end
+
+      private
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def parse_tokens
+        t = @tokenizer
+
+        case t.token
+
+        when CALL
+          return unless scan_until IDENT
+          "CALL #{t.text}"
+
+        when DELETE
+          return unless scan_until FROM
+          return unless scan_token IDENT
+          table = scan_dotted_identifier
+          "DELETE FROM #{table}"
+
+        when INSERT, REPLACE
+          action = t.text
+          return unless scan_until INTO
+          return unless scan_token IDENT
+          table = scan_dotted_identifier
+          "#{action} INTO #{table}"
+
+        when SELECT
+          level = 0
+          while t.scan
+            case t.token
+            when LPAREN then level += 1
+            when RPAREN then level -= 1
+            when FROM
+              next unless level == 0
+              break unless scan_token IDENT
+              table = scan_dotted_identifier
+              return "SELECT FROM #{table}"
+            end
+          end
+
+        when UPDATE
+          # Scan for the table name. Some dialects allow option keywords before
+          # the table name.
+          return 'UPDATE' unless scan_token IDENT
+
+          table = t.text
+
+          period = false
+          first_period = false
+
+          while t.scan
+            case t.token
+            when IDENT
+              if period
+                table += t.text
+                period = false
+              end
+
+              unless first_period
+                table = t.text
+              end
+
+              # Two adjacent identifiers found after the first period. Ignore
+              # the secondary ones, in case they are unknown keywords.
+            when PERIOD
+              period = true
+              first_period = true
+              table += '.'
+            else
+              return "UPDATE #{table}"
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      # Scans until finding token of `kind`
+      def scan_until(kind)
+        while @tokenizer.scan
+          break true if @tokenizer.token == kind
+          false
+        end
+      end
+
+      # Scans next token, ignoring comments
+      # Returns whether next token is of `kind`
+      def scan_token(kind)
+        while @tokenizer.scan
+          next if @tokenizer.token == COMMENT
+          break
+        end
+
+        return true if @tokenizer.token == kind
+
+        false
+      end
+
+      def scan_dotted_identifier
+        table = @tokenizer.text
+
+        while scan_token(PERIOD) && scan_token(IDENT)
+          table += ".#{@tokenizer.text}"
+        end
+
+        table
+      end
+    end
+  end
+end

data/lib/elastic_apm/sql/tokenizer.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require 'strscan'
+require 'elastic_apm/sql/tokens'
+
+module ElasticAPM
+  module Sql
+    # @api private
+    class Tokenizer
+      include Tokens
+
+      ALPHA = /[[:alpha:]]/.freeze
+      DIGIT = /[[:digit:]]/.freeze
+      SPACE = /[[:space:]]+/.freeze
+
+      def initialize(input)
+        @input = input
+
+        @scanner = StringScanner.new(input)
+        @byte_start = 0
+      end
+
+      attr_reader :input, :scanner, :token
+
+      def text
+        @input.byteslice(@byte_start, @byte_end - @byte_start)
+      end
+
+      def scan
+        scanner.skip(SPACE)
+
+        @byte_start = scanner.pos
+        char = next_char
+
+        return false unless char
+
+        @token = next_token(char)
+
+        true
+      end
+
+      private
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def next_token(char)
+        case char
+        when '_'   then scan_keyword_or_identifier(possible_keyword: false)
+        when '.'   then PERIOD
+        when '$'   then scan_dollar_sign
+        when '`'   then scan_quoted_indentifier('`')
+        when '"'   then scan_quoted_indentifier('"')
+        when '['   then scan_quoted_indentifier(']')
+        when '('   then LPAREN
+        when ')'   then RPAREN
+        when '/'   then scan_bracketed_comment
+        when '-'   then scan_simple_comment
+        when "'"   then scan_string_literal
+        when ALPHA then scan_keyword_or_identifier(possible_keyword: true)
+        when DIGIT then scan_numeric_literal
+        else            OTHER
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def next_char
+        char = @scanner.getch
+        @byte_end = @scanner.pos
+        char
+      end
+
+      # StringScanner#peek returns next byte which could be an incomplete utf
+      # multi-byte character
+      def peek_char(length = 1)
+        # The maximum byte count of utf chars is 4:
+        # > In UTF-8, characters from the U+0000..U+10FFFF range (the UTF-16
+        #   accessible range) are encoded using sequences of 1 to 4 octets.
+        # # https://tools.ietf.org/html/rfc3629
+        return nil if length > 4
+
+        char = @scanner.peek(length)
+
+        return nil if char.empty?
+        return char if char.valid_encoding?
+
+        peek_char(length + 1)
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def scan_keyword_or_identifier(possible_keyword:)
+        while (peek = peek_char)
+          if peek == '_' || peek == '$' || peek =~ DIGIT
+            possible_keyword = false
+            next next_char
+          end
+
+          next next_char if peek =~ ALPHA
+
+          break
+        end
+
+        return IDENT unless possible_keyword
+
+        snap = text
+
+        if snap.length < KEYWORD_MIN_LENGTH || snap.length > KEYWORD_MAX_LENGTH
+          return IDENT
+        end
+
+        keyword = KEYWORDS[snap.length].find { |kw| snap.upcase == kw.to_s }
+        return keyword if keyword
+
+        IDENT
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def scan_dollar_sign
+        while (peek = peek_char)
+          case peek
+          when DIGIT
+            next_char while peek_char =~ DIGIT
+          when '$', '_', ALPHA, SPACE
+            # PostgreSQL supports dollar-quoted string literal syntax,
+            # like $foo$...$foo$. The tag (foo in this case) is optional,
+            # and if present follows identifier rules.
+            while (char = next_char)
+              case char
+              when '$'
+                # This marks the end of the initial $foo$.
+                snap = text
+                slice = input.slice(scanner.pos, input.length)
+                index = slice.index(snap)
+                next unless index && index >= 0
+
+                delta = index + snap.bytesize
+                @byte_end += delta
+                scanner.pos += delta
+                return STRING
+              when SPACE
+                # Unknown token starting with $, consume chars until space.
+                @byte_end -= char.bytesize
+                return OTHER
+              end
+            end
+          else break
+          end
+        end
+
+        OTHER
+      end
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+      def scan_quoted_indentifier(delimiter)
+        while (char = next_char)
+          next unless char == delimiter
+
+          if delimiter == '"' && peek_char == delimiter
+            next next_char
+          end
+
+          break
+        end
+
+        # Remove quotes from identifier
+        @byte_start += char.bytesize
+        @byte_end -= char.bytesize
+
+        IDENT
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def scan_bracketed_comment
+        return OTHER unless peek_char == '*'
+
+        nesting = 1
+
+        while (char = next_char)
+          case char
+          when '/'
+            next unless peek_char == '*'
+            next_char
+            nesting += 1
+          when '*'
+            next unless peek_char == '/'
+            next_char
+            nesting -= 1
+            return COMMENT if nesting == 0
+          end
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def scan_simple_comment
+        return OTHER unless peek_char == '-'
+
+        while (char = next_char)
+          break if char == "\n"
+        end
+
+        COMMENT
+      end
+
+      def scan_string_literal
+        delimiter = "'"
+
+        while (char = next_char)
+          if char == '\\'
+            # Skip escaped character, e.g. 'what\'s up?'
+            next_char
+            next
+          end
+
+          next unless char == delimiter
+
+          return STRING unless peek_char
+          return STRING if peek_char != delimiter
+
+          next_char
+        end
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def scan_numeric_literal
+        period = false
+        exponent = false
+
+        while (peek = peek_char)
+          case peek
+          when DIGIT then next_char
+          when '.'
+            return NUMBER if period
+            next_char
+            period = true
+          when 'e', 'E'
+            return NUMBER if exponent
+            next_char
+            next_char if peek_char =~ /[+-]/
+          else break
+          end
+        end
+
+        NUMBER
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end