atatus 1.3.0 → 1.4.0

data/lib/atatus/spies/sucker_punch.rb

@@ -0,0 +1,58 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class SuckerPunchSpy
+      TYPE = 'sucker_punch'
+
+      def install
+        if defined?(::SuckerPunch) && defined?(::SuckerPunch::Job) && defined?(::SuckerPunch::Job::ClassMethods)
+
+          ::SuckerPunch::Job::ClassMethods.class_eval do
+            alias :__run_perform_without_atatus :__run_perform
+
+            def __run_perform(*args)
+              # This method is reached via JobClass#async_perform
+              # or JobClass#perform_in.
+              name = to_s
+              transaction = Atatus.start_transaction(name, TYPE)
+              __run_perform_without_atatus(*args)
+              transaction.done 'success'
+            rescue ::Exception => e
+              # Note that SuckerPunch by default doesn't raise the errors from
+              # the user-defined JobClass#perform method as it uses an error
+              # handler, accessed via `SuckerPunch.exception_handler`.
+              Atatus.report(e, handled: false)
+              transaction.done 'error'
+              raise
+            ensure
+              Atatus.end_transaction
+            end
+          end
+
+        end
+      end
+    end
+
+    register 'SuckerPunch', 'sucker_punch', SuckerPunchSpy.new
+  end
+end

data/lib/atatus/spies/tilt.rb

@@ -1,3 +1,20 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
 # frozen_string_literal: true
 
 module Atatus
@@ -8,7 +25,8 @@ module Atatus
       TYPE = 'template.tilt'
 
       def install
-        if defined?(::Tilt) && defined?(::Tilt::Template) 
+        if defined?(::Tilt) && defined?(::Tilt::Template)
+
           ::Tilt::Template.class_eval do
             alias render_without_apm render
 
@@ -20,6 +38,7 @@ module Atatus
               end
             end
           end
+
         end
       end
     end

data/lib/atatus/sql.rb

@@ -0,0 +1,36 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module Atatus
+  # @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 Atatus.agent&.config&.use_legacy_sql_parser
+          require 'atatus/sql_summarizer'
+          SqlSummarizer.new
+        else
+          require 'atatus/sql/signature'
+          Sql::Signature::Summarizer.new
+        end
+    end
+  end
+end

data/lib/atatus/sql/signature.rb

@@ -0,0 +1,169 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require 'atatus/sql/tokenizer'
+
+module Atatus
+  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/atatus/sql/tokenizer.rb

@@ -0,0 +1,264 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require 'strscan'
+require 'atatus/sql/tokens'
+
+module Atatus
+  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