stackify-ruby-apm 1.0.1 → 1.1.0

data/lib/stackify/spies/sinatra_activerecord/sqlite_adapter.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-# Spies for active record when sinatra framework is used and active_record is being extended. (mysql adapter)
-#
-module StackifyRubyAPM
-    # @api private
-    module Spies
-      # @api private
-      class SqliteAdapterSpy
-        TYPE = 'db.sinatra_active_record.sql'.freeze
-  
-        # rubocop:disable Metrics/MethodLength
-        def install
-          ActiveRecord::ConnectionAdapters::SQLite3Adapter.class_eval do
-            alias exec_query_without_apm exec_query
-            
-            
-            def exec_query(sql, name = "SQL", binds = [], prepare: false)
-              result = nil
-  
-              unless StackifyRubyAPM.current_transaction
-                exec_query_without_apm(sql, name, binds)
-              end
-  
-              ctx = Span::Context.new(
-                CATEGORY: 'Database',
-                SUBCATEGORY: 'Execute',
-                COMPONENT_CATEGORY: 'DB Query',
-                COMPONENT_DETAIL: 'Execute SQL Query',
-                SQL: sql,
-                PROVIDER: "sqlite"
-              )
-              
-              result = exec_query_without_apm(sql, name, binds)
-  
-              StackifyRubyAPM.span name, TYPE, context: ctx do
-                return result
-              end
-            end
-  
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-      end
-  
-      register 'ActiveRecord::ConnectionAdapters::SQLite3Adapter', 'active_record/connection_adapters/sqlite3_adapter', SqliteAdapterSpy.new
-    end
-  end
-  

data/lib/stackify/stacktrace.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-#
-# This module starts creation for frames
-#
-module StackifyRubyAPM
-    # @api private
-    class Stacktrace
-      attr_accessor :frames
-  
-      def length
-        frames.length
-      end
-  
-      def to_a
-        frames.map(&:to_h)
-      end
-    end
-  end
-  

data/lib/stackify/stacktrace/frame.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module StackifyRubyAPM
-    class Stacktrace
-      # @api private
-      class Frame
-        include NaivelyHashable
-  
-        attr_accessor(
-          :abs_path,
-          :filename,
-          :function,
-          :vars,
-          :pre_context,
-          :context_line,
-          :post_context,
-          :library_frame,
-          :lineno,
-          :module,
-          :Method,
-          :colno
-        )
-  
-        # rubocop:disable Metrics/AbcSize
-        def build_context(context_line_count)
-          return unless abs_path && context_line_count > 0
-  
-          padding = (context_line_count - 1) / 2
-          from = lineno - padding - 1
-          from = 0 if from < 0
-          to = lineno + padding - 1
-          file_lines = read_lines(abs_path, from..to)
-  
-          self.context_line = file_lines[padding]
-          self.pre_context  = file_lines.first(padding)
-          self.post_context = file_lines.last(padding)
-        end
-        # rubocop:enable Metrics/AbcSize
-  
-        private
-  
-        def read_lines(path, range)
-          File.readlines(path)[range]
-        rescue Errno::ENOENT
-          []
-        end
-      end
-    end
-  end
-  

data/lib/stackify/transaction.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-#
-# This class creates and initializes a new transaction.
-#
-
-module StackifyRubyAPM
-    require 'securerandom'
-    # @api private
-    class Transaction
-        DEFAULT_TYPE = 'custom'.freeze
-
-        # rubocop:disable Metrics/MethodLength
-        def initialize  instrumenter, name = nil, type = nil, context: nil
-          # puts "Loads transaction new initialize  instrumenter, name = nil, type = nil, context: nil"
-          @id = SecureRandom.uuid
-          @instrumenter = instrumenter
-          @name = name
-          @type = type || DEFAULT_TYPE
-          @timestamp = (Time.now).to_f * 1000
-
-          @spans = []
-          @span_id_ticker = -1
-          @dropped_spans = 0
-
-          @notifications = [] # for AS::Notifications
-          @context = context || Context.new
-          @exceptions = []
-
-          yield self if block_given?
-        end
-        # rubocop:enable Metrics/MethodLength
-
-        attr_accessor :name, :type, :http_status
-        attr_reader :id, :context, :duration, :dropped_spans,
-            :timestamp, :spans, :result, :notifications, :instrumenter, :exceptions
-
-        def add_exception exception
-          @exceptions << exception
-        end
-
-        def release
-          @instrumenter.current_transaction = nil
-        end
-
-        def done result = nil
-          @duration = (Time.now).to_f * 1000
-          @result = result
-          @http_status = result
-
-          self
-        end
-
-        def done?
-          !!@duration
-        end
-
-        def submit result = nil, status: nil, headers: {}
-          done result unless duration
-          if status
-            context.response = Context::Response.new(status, headers: headers)
-          end
-
-          release
-          @instrumenter.submit_transaction self
-
-          self
-        end
-        # This method is being used in unit testing
-        def running_spans
-          spans.select(&:running?)
-        end
-        # rubocop:disable Metrics/MethodLength
-        def span name, type = nil, backtrace: nil, context: nil
-          span = build_and_start_span(name, type, context, backtrace)
-          return span unless block_given?
-
-          begin
-            result = yield span
-          ensure
-            span.done
-          end
-
-          result
-        end
-        # rubocop:enable Metrics/MethodLength
-
-        def current_span
-          spans.reverse.lazy.find(&:running?)
-        end
-
-        def inspect
-          "<StackifyRubyAPM::Transaction id:#{id}" \
-          " name:#{name.inspect}" \
-          " type:#{type.inspect}" \
-          '>'
-        end
-
-        private
-
-        def next_span_id
-          @span_id_ticker += 1
-        end
-
-        def next_span name, type, context
-          Span.new(
-            self,
-            next_span_id,
-            name,
-            type,
-            parent_id: current_span.nil? ? -1 : current_span.id,
-            context: context,
-            http_status: @http_status
-          )
-        end
-
-        def span_frames_min_duration?
-          @instrumenter.agent.config.span_frames_min_duration != 0
-        end
-
-        def build_and_start_span name, type, context, backtrace
-          span = next_span(name, type, context)
-          spans << span
-
-          if backtrace && span_frames_min_duration?
-            span.original_backtrace = backtrace
-          end
-
-          span.start
-        end
-
-    end
-end

data/lib/stackify/util/lru_cache.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module StackifyRubyAPM
-    module Util
-      # @api private
-      class LruCache
-        def initialize(max_size = 512, &block)
-          @max_size = max_size
-          @data = Hash.new(&block)
-          @mutex = Mutex.new
-        end
-  
-        def [](key)
-          @mutex.synchronize do
-            val = @data[key]
-            return unless val
-            add(key, val)
-            val
-          end
-        end
-  
-        def []=(key, val)
-          @mutex.synchronize do
-            add(key, val)
-          end
-        end
-  
-        def length
-          @data.length
-        end
-  
-        def to_a
-          @data.to_a
-        end
-  
-        private
-  
-        def add(key, val)
-          @data.delete(key)
-          @data[key] = val
-  
-          return unless @data.length > @max_size
-  
-          @data.delete(@data.first[0])
-        end
-      end
-    end
-  end
-  

data/lib/stackify/version.rb

@@ -1,4 +0,0 @@
-# Sets the version of the APM
-module StackifyRubyAPM
-  VERSION = '1.0.1'.freeze
-end