stackify-ruby-apm 1.11.1 → 1.12.3

data/lib/stackify_apm/serializers/transactions.rb

@@ -125,6 +125,11 @@ module StackifyRubyAPM
 
         span_context = span.context && span.context.to_h
 
+        if span_context && !span_context[:SQL].nil? && span_context[:SQL].length > 100_000
+          span_context[:SQL] = span_context[:SQL][0..99_999]
+          span_context[:SQL_TRUNCATED] = 'true'
+        end
+
         {
           id: span.id,
           parent_id: span.parent_id,

data/lib/stackify_apm/span/context.rb

@@ -17,6 +17,8 @@ module StackifyRubyAPM
                     :COMPONENT_CATEGORY,
                     :COMPONENT_DETAIL,
                     :SQL,
+                    :SQL_PARAMETERS,
+                    :SQL_TRUNCATED,
                     :MONGODB_COLLECTION,
                     :METHOD,
                     :URL,
@@ -27,11 +29,47 @@ module StackifyRubyAPM
                     :CACHENAME,
                     :THREAD_ID,
                     :ID,
-                    :TRACKED_FUNC
+                    :TRACKED_FUNC,
+                    :LEVEL,
+                    :MESSAGE,
+                    :EXCEPTION,
+                    :REQUEST_BODY,
+                    :REQUEST_SIZE_BYTES,
+                    :REQUEST_HEADERS,
+                    :RESPONSE_BODY,
+                    :RESPONSE_SIZE_BYTES,
+                    :RESPONSE_HEADERS
       # rubocop:disable Style/VariableName
       def update_status(status)
         @STATUS = status
       end
+
+      def update_request_body(body)
+        @REQUEST_BODY = body.to_s
+        @REQUEST_SIZE_BYTES = body.to_s.length.to_s
+      end
+
+      def update_request_headers(headers)
+        @REQUEST_HEADERS = to_json_list(headers)
+      end
+
+      def update_response_body(body)
+        @RESPONSE_BODY = body.to_s
+        @RESPONSE_SIZE_BYTES = body.to_s.length.to_s
+      end
+
+      def update_response_headers(headers)
+        @RESPONSE_HEADERS = to_json_list(headers)
+      end
+
+      private
+      def to_json_list(header)
+        list_header = []
+        header.each do |key, value|
+          list_header << {key => value}
+        end
+        list_header.to_json
+      end
       # rubocop:enable Style/VariableName
     end
   end

data/lib/stackify_apm/spies.rb

@@ -85,8 +85,10 @@ module StackifyRubyAPM
     end
 
     def self.class_exists?(class_name)
-      klass = Module.const_get(class_name)
-      return klass.is_a?(Class)
+      if class_name
+        klass = Module.const_get(class_name)
+        return klass.is_a?(Class)
+      end
     rescue NameError
       return false
     end

data/lib/stackify_apm/spies/action_dispatch.rb

@@ -14,7 +14,12 @@ module StackifyRubyAPM
           def render_exception(env, exception)
             # Creates exception log report
             #
-            StackifyRubyAPM.report(exception)
+            begin
+              StackifyRubyAPM.report(exception)
+            rescue Exception => e
+              StackifyRubyAPM.agent.error '[ActionDispatchSpy] Error: repoting exception.'
+              StackifyRubyAPM.agent.error "[ActionDispatchSpy] #{e.inspect}"
+            end
             render_exception_without_apm env, exception
           end
         end

data/lib/stackify_apm/spies/curb.rb

@@ -13,30 +13,51 @@ module StackifyRubyAPM
           def self.http(verb, url, _post_body = nil, _put_data = nil, &block)
             req = nil
             return http_without_apm(verb, url, _post_body = nil, _put_data = nil, &block) unless StackifyRubyAPM.current_transaction
-            # Data configuration
-            #
-            method = verb
-            uri = url.strip
-            name = "#{method} #{uri}"
-            type = "ext.Curb.#{method}"
-            # Submits HTTP request
-            #
-            req = http_without_apm(verb, url, _post_body = nil, _put_data = nil, &block)
-            # Builds span context
-            #
-            status_code = req.status.sub(/^0-9/, '').to_i
 
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: status_code,
-              METHOD: method
-            )
+            begin
+              # Data configuration
+              #
+              method = verb
+              uri = url.strip
+              name = "#{method} #{uri}"
+              type = "ext.Curb.#{method}"
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[CurbSpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[CurbSpy] #{e.inspect}"
+              return http_without_apm(verb, url, _post_body = nil, _put_data = nil, &block)
+            end
+
             # Creates new span from HTTP result
             #
             StackifyRubyAPM.span name, type, context: ctx do
-              req
+              # Submits HTTP request
+              #
+              res = http_without_apm(verb, url, _post_body = nil, _put_data = nil, &block)
+              begin
+                # Builds span context
+                #
+                status_code = res.status.sub(/^0-9/, '').to_i
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body(_post_body || _put_data || "")
+                  ctx.update_request_headers(res.headers || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.proxy_headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[NetHTTPSpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[NetHTTPSpy] #{e.inspect}"
+              end
+              res
             end
           end
         end

data/lib/stackify_apm/spies/curb/easy.rb

@@ -19,132 +19,260 @@ module StackifyRubyAPM
           def self.perform(*args)
             req = nil
             return perform_without_apm(*args) unless StackifyRubyAPM.current_transaction
-            # Data configuration
-            @_apm_http_verb ||= :GET
-            method = @_apm_http_verb
-            uri = args[0].strip
-            name = "#{method} #{uri}"
-            type = "ext.Curb.Easy.#{method}"
-            # Submits HTTP request
-            #
-            req = perform_without_apm(*args)
-            # Builds span context
-            #
-            status_code = req.status.sub(/^0-9/, '').to_i
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: status_code,
-              METHOD: method
-            )
+
+            begin
+              # Data configuration
+              @_apm_http_verb ||= :GET
+              method = @_apm_http_verb
+              uri = args[0].strip
+              name = "#{method} #{uri}"
+              type = "ext.Curb.Easy.#{method}"
+
+              # Builds span context
+              #
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[CurbEasySpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              return perform_without_apm(*args)
+            end
+
             # Creates new span from HTTP result
             StackifyRubyAPM.span name, type, context: ctx do
-              req
+              # Submits HTTP request
+              #
+              res = perform_without_apm(*args)
+
+              begin
+                status_code = res.status.sub(/^0-9/, '').to_i
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body("")
+                  ctx.update_request_headers(res.headers || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.proxy_headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[CurbEasySpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              end
+              res
             end
           end
 
           def self.http_post(*args)
             req = nil
             return http_post_without_apm(*args) unless StackifyRubyAPM.current_transaction
-            # Data configuration
-            #
-            @_apm_http_verb = :POST
-            method = @_apm_http_verb
-            uri = args[0].strip
-            name = "#{method} #{uri}"
-            type = "ext.Curb.Easy.#{method}"
-            req = http_post_without_apm(*args)
-            status_code = req.status.sub(/^0-9/, '').to_i
-
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: status_code,
-              METHOD: method
-            )
+
+            begin
+              # Data configuration
+              #
+              @_apm_http_verb = :POST
+              method = @_apm_http_verb
+              uri = args[0].strip
+              name = "#{method} #{uri}"
+              type = "ext.Curb.Easy.#{method}"
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[CurbEasySpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              return http_post_without_apm(*args)
+            end
+
             # Creates new span from HTTP result
             StackifyRubyAPM.span name, type, context: ctx do
-              req
+              res = http_post_without_apm(*args)
+
+              begin
+                status_code = res.status.sub(/^0-9/, '').to_i
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  if args.length == 2
+                    request_body = args[1].to_s
+                  elsif args.length > 2
+                    request_body = {}
+                    contents = args[1..-1]
+                    contents.each do |data|
+                      request_body[data.name] = data.content
+                    end
+                    request_body = request_body.to_json
+                  else
+                    request_body = ""
+                  end
+
+                  ctx.update_request_body(request_body)
+                  ctx.update_request_headers(res.headers || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.proxy_headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[CurbEasySpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              end
+
+              res
             end
           end
 
           def self.http_put(url, data)
             req = nil
             return http_put_without_apm(url, data) unless StackifyRubyAPM.current_transaction
-            # Data configuration
-            #
-            @_apm_http_verb = :PUT
-            method = @_apm_http_verb
-            uri = url.strip
-            name = "#{method} #{uri}"
-            type = "ext.Curb.Easy.#{method}"
-            req = http_put_without_apm(url, data)
-            status_code = req.status.sub(/^0-9/, '').to_i
-
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: status_code,
-              METHOD: method
-            )
+
+            begin
+              # Data configuration
+              #
+              @_apm_http_verb = :PUT
+              method = @_apm_http_verb
+              uri = url.strip
+              name = "#{method} #{uri}"
+              type = "ext.Curb.Easy.#{method}"
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[CurbEasySpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              return http_put_without_apm(url, data)
+            end
+
             # Creates new span from HTTP result
             StackifyRubyAPM.span name, type, context: ctx do
-              req
+              res = http_put_without_apm(url, data)
+
+              begin
+                status_code = res.status.sub(/^0-9/, '').to_i
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body(data)
+                  ctx.update_request_headers(res.headers || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.proxy_headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[CurbEasySpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              end
+
+              res
             end
           end
 
           def self.http_get(*args)
             req = nil
             return http_get_without_apm(*args) unless StackifyRubyAPM.current_transaction
-            # Data configuration
-            #
-            @_apm_http_verb = :GET
-            method = @_apm_http_verb
-            uri = args[0].strip
-            name = "#{method} #{uri}"
-            type = "ext.Curb.Easy.#{method}"
-            req = http_get_without_apm(*args)
-            status_code = req.status.sub(/^0-9/, '').to_i
-
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: status_code,
-              METHOD: method
-            )
+
+            begin
+              # Data configuration
+              #
+              @_apm_http_verb = :GET
+              method = @_apm_http_verb
+              uri = args[0].strip
+              name = "#{method} #{uri}"
+              type = "ext.Curb.Easy.#{method}"
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[CurbEasySpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              return http_get_without_apm(*args)
+            end
+
             # Creates new span from HTTP result
             StackifyRubyAPM.span name, type, context: ctx do
-              req
+              res = http_get_without_apm(*args)
+
+              begin
+                status_code = res.status.sub(/^0-9/, '').to_i
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body("")
+                  ctx.update_request_headers(res.headers || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.proxy_headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[CurbEasySpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              end
+
+              res
             end
           end
 
           def self.http_delete(*args)
             req = nil
             return http_delete_without_apm(*args) unless StackifyRubyAPM.current_transaction
-            # Data configuration
-            #
-            @_apm_http_verb = :DELETE
-            method = @_apm_http_verb
-            uri = args[0].strip
-            name = "#{method} #{uri}"
-            type = "ext.Curb.Easy.#{method}"
-            req = http_delete_without_apm(*args)
-            status_code = req.status.sub(/^0-9/, '').to_i
-
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: status_code,
-              METHOD: method
-            )
+
+            begin
+              # Data configuration
+              #
+              @_apm_http_verb = :DELETE
+              method = @_apm_http_verb
+              uri = args[0].strip
+              name = "#{method} #{uri}"
+              type = "ext.Curb.Easy.#{method}"
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[CurbEasySpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              return http_delete_without_apm(*args)
+            end
+
             # Creates new span from HTTP result
             StackifyRubyAPM.span name, type, context: ctx do
-              req
+              res = http_delete_without_apm(*args)
+
+              begin
+                status_code = res.status.sub(/^0-9/, '').to_i
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body("")
+                  ctx.update_request_headers(res.headers || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.proxy_headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[CurbEasySpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[CurbEasySpy] #{e.inspect}"
+              end
+
+              res
             end
           end
         end