stackify-ruby-apm 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f5b0114ca432b384986bef0196ff170ddc28d29
+  data.tar.gz: 8c5850539e077d39f1b0542a9bc4c80a9d5c21cf
+SHA512:
+  metadata.gz: 51f466a4778791cb024cb072a38e590cf8f07e09a7e202be694d6bb6a97be1ea501ccb79a057c68c538e1a18186b8a375b894d8133845eb6c44608d6ec3a6681
+  data.tar.gz: a858da77af22d0f32415377fdd454effb880fccb7ebf2e82d2045c1da1d9d451634a5405539cae2ebcb040db701b659296828428e06c6b44f72129a3836dd29c

data/.gitignore

@@ -0,0 +1,76 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore bundler config.
+/.bundle
+
+# Deps
+node_modules
+
+# IDE
+.idea
+
+# VS Code
+.vscode
+.vs
+
+# Unnecessary since this will be a plugin
+package-lock.json
+
+# Folder config file
+Desktop.ini
+
+# Windows shortcuts
+*.lnk
+
+### OSX ###
+/**/.DS_Store
+/.DS_Store
+.AppleDouble
+.LSOverride
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes
+
+### Linux ###
+*~
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Ignore .byebug_history, .rspec, brakeman.html
+.byebug_history
+.rspec
+brakeman.html
+
+
+# Gem
+*.gem
+
+#bin
+bin
+bin/*
+

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in stackify-ruby-apm.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,68 @@
+PATH
+  remote: .
+  specs:
+    stackify-ruby-apm (0.9.0)
+      concurrent-ruby (~> 1.0)
+      delegate_matcher (~> 0.4)
+      webmock (~> 3.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
+    concurrent-ruby (1.1.3)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    delegate_matcher (0.4.3)
+      proc_extensions (~> 0.2)
+    diff-lcs (1.3)
+    file-tail (1.2.0)
+      tins (~> 1.0)
+    hashdiff (0.3.7)
+    proc_extensions (0.2)
+      sourcify (~> 0.5)
+    public_suffix (3.0.3)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    ruby2ruby (2.4.1)
+      ruby_parser (~> 3.1)
+      sexp_processor (~> 4.6)
+    ruby_parser (3.11.0)
+      sexp_processor (~> 4.9)
+    safe_yaml (1.0.4)
+    sexp_processor (4.11.0)
+    sourcify (0.5.0)
+      file-tail (>= 1.0.5)
+      ruby2ruby (>= 1.2.5)
+      ruby_parser (>= 2.0.5)
+      sexp_processor (>= 3.0.5)
+    tins (1.19.0)
+    webmock (3.4.2)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  stackify-ruby-apm!
+
+BUNDLED WITH
+   1.16.4

data/README.md

@@ -0,0 +1,23 @@
+
+# Stackify Ruby APM
+
+## Installation Guide 
+
+1. Install **Stackify Linux Agent**. 
+
+2. Check that your setup meets our system requirements. 
+    * Ruby version 2.5+
+    * Framework 
+        * Ruby on Rails 5.2+
+    * Operating System 
+        * Linux
+
+3. Add `gem 'stackify-ruby-apm'` to your `Gemfile`.
+
+4. In the root folder of your Rails app create a file `config/stackify_apm.yml` and then add this configuration
+    ```yaml
+    application_name: 'Ruby Application'
+    environment_name: 'Production'
+    ```
+5. Build/Deploy your application:
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/stackify-ruby-apm.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Make bundler auto-require work
+require 'stackify_ruby_apm'

data/lib/stackify/agent.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+#
+# The Agent interacts with the Web Application and Profiler.
+# It is also responsible in requesting the instrumenter to build the transactions and spans.
+#
+
+require 'stackify/naively_hashable'
+require 'stackify/context_builder'
+require 'stackify/error_builder'
+require 'stackify/stacktrace_builder'
+require 'stackify/error'
+require 'stackify/trace_logger'
+require 'stackify/spies'
+require 'stackify/serializers'
+require 'stackify/worker'
+
+module StackifyRubyAPM
+  class Agent
+    include Log
+
+    LOCK = Mutex.new
+
+    def self.instance # rubocop:disable Style/TrivialAccessors
+      @instance
+    end
+
+    def self.start(config)
+      return @instance if @instance
+      config = Config.new(config) unless config.is_a?(Config)
+      LOCK.synchronize do
+        return @instance if @instance
+        @instance = new(config).start
+      end
+    end
+
+    def self.stop
+      LOCK.synchronize do
+        return unless @instance
+
+        @instance.stop
+        @instance = nil
+      end
+    end
+
+    def stop
+      @instrumenter.stop
+      kill_worker
+      self
+    end
+
+    def self.running?
+      !!@instance
+    end
+
+    def initialize(config)
+      # puts '@stackify_ruby [Agent] [lib/agent.rb] initialize()'
+      @config = config
+      @trace_logger = TraceLogger.new(config)
+      @messages = Queue.new
+      @pending_transactions = Queue.new
+      @instrumenter = Instrumenter.new(self)
+      @context_builder = ContextBuilder.new(self)
+      @error_builder = ErrorBuilder.new(self)
+      @stacktrace_builder = StacktraceBuilder.new(self)
+    end
+
+    attr_reader :config,
+                :messages,
+                :pending_transactions,
+                :instrumenter,
+                :context_builder,
+                :stacktrace_builder,
+                :trace_logger,
+                :error_builder
+
+    def start
+      # puts '@stackify_ruby [Agent] [lib/agent.rb] start()'
+      # puts '@stackify_ruby [Agent] [lib/agent.rb] Environment: ' + @config.environment_name
+      # puts '@stackify_ruby [Agent] [lib/agent.rb] Application Name: ' + @config.application_name
+      # @instrumenter.start
+      debug 'Loaded spies:'
+      config.enabled_spies.each do |lib|
+        debug lib.inspect
+        require "stackify/spies/#{lib}"
+      end
+      self
+    end
+
+    # queues
+
+    # Stores transaction in queue
+    #
+    def enqueue_transaction(transaction)
+      boot_worker unless worker_running?
+      pending_transactions.push(transaction)
+      return unless should_flush_transactions?
+
+      messages.push(Worker::FlushMsg.new)
+    end
+
+    def should_flush_transactions?
+      return true unless config.flush_interval
+      return true if pending_transactions.length >= config.max_queue_size
+
+      false
+    end
+
+    def enqueue_error(error)
+      boot_worker unless worker_running?
+
+      messages.push(Worker::ErrorMsg.new(error))
+    end
+
+    # Instrumentation
+    #
+    def current_transaction
+      instrumenter.current_transaction
+    end
+
+    # Loads transaction
+    #
+    def transaction(*args, &block)
+      instrumenter.transaction(*args, &block)
+    end
+
+    def span(*args, &block)
+      instrumenter.span(*args, &block)
+    end
+
+    # Responsible for building the transaction's context
+    #
+    def build_context(rack_env)
+      @context_builder.build(rack_env)
+    end
+
+    # errors
+
+    def report(exception, handled: true)
+      return if config.filter_exception_types.include?(exception.class.to_s)
+
+      error = @error_builder.build_exception(
+        exception,
+        handled: handled
+      )
+      enqueue_error error
+    end
+
+    def report_message(message, backtrace: nil, **attrs)
+      error = @error_builder.build_log(
+        message,
+        backtrace: backtrace,
+        **attrs
+      )
+      enqueue_error error
+    end
+
+    private
+
+    def boot_worker
+      debug 'Booting worker'
+
+      @worker_thread = Thread.new do
+        Worker.new(
+            config,
+            messages,
+            pending_transactions,
+            trace_logger
+        ).run_forever
+      end
+    end
+
+    def kill_worker
+      messages << Worker::StopMsg.new
+
+      if @worker_thread && !@worker_thread.join(5) # 5 secs
+        raise 'Failed to wait for worker, not all messages sent'
+      end
+
+      @worker_thread = nil
+    end
+
+    def worker_running?
+      @worker_thread && @worker_thread.alive?
+    end
+  end
+end

data/lib/stackify/config.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+#
+# The Config class sets the APM's default values.
+#
+
+require 'logger'
+require 'yaml'
+require 'socket'
+module StackifyRubyAPM
+  # rubocop:disable Metrics/ClassLength
+  # @api private
+  class Config
+    DEFAULTS = {
+      config_file: 'config/stackify_apm.yml',
+      environment_name: ENV['RAILS_ENV'] || ENV['RACK_ENV'],
+      instrument: true,
+
+      log_path: '/usr/local/stackify/stackify-ruby-apm/log/stackify-ruby-apm.log',
+      log_level: Logger::DEBUG,
+
+      log_trace_path: '/usr/local/stackify/stackify-ruby-apm/log/',
+
+      max_queue_size: 500, # Maximum queue length of transactions before sending transactions to the APM.
+      flush_interval: 1, # interval with which transactions should be sent to the APM. Default value: 10 seconds
+      
+      filter_exception_types: [],
+
+      http_status: nil,
+      debug_transactions: false,
+      
+      source_lines_error_app_frames: 5,
+      source_lines_span_app_frames: 5,
+      source_lines_error_library_frames: 0,
+      source_lines_span_library_frames: 0,
+      span_frames_min_duration: -1, # it will collect stack traces for all spans
+
+      disabled_spies: %w[json],
+
+      view_paths: [],
+      root_path: Dir.pwd
+    }.freeze
+
+    ENV_TO_KEY = {
+      'STACKIFY_APM_ENVIRONMENT_NAME' => 'environment_name',
+      'STACKIFY_APM_INSTRUMENT' => [:bool, 'instrument'],
+      'STACKIFY_APM_HOSTNAME' => 'hostname',
+      'STACKIFY_APM_LOG_PATH' => 'log_path',
+      'STACKIFY_APM_LOG_LEVEL' => [:int, 'log_level'],
+      'STACKIFY_APM_APPLICATION_NAME' => 'application_name',
+      'STACKIFY_APM_SOURCE_LINES_ERROR_APP_FRAMES' => [:int, 'source_lines_error_app_frames'],
+      'STACKIFY_APM_SOURCE_LINES_SPAN_APP_FRAMES' => [:int, 'source_lines_span_app_frames'],
+      'STACKIFY_APM_SOURCE_LINES_ERROR_LIBRARY_FRAMES' => [:int, 'source_lines_error_library_frames'],
+      'STACKIFY_APM_SOURCE_LINES_SPAN_LIBRARY_FRAMES' => [:int, 'source_lines_span_library_frames'],
+      'STACKIFY_APM_SPAN_FRAMES_MIN_DURATION' => [:int, 'span_frames_min_duration'],
+      'STACKIFY_APM_MAX_QUEUE_SIZE' => [:int, 'max_queue_size'],
+      'STACKIFY_APM_FLUSH_INTERVAL' => 'flush_interval',
+      'STACKIFY_APM_DISABLED_SPIES' => [:list, 'disabled_spies']
+    }.freeze
+
+    def initialize(options = {})
+      set_defaults
+
+      set_from_args(options)
+      set_from_config_file
+      set_from_env
+
+      yield self if block_given?
+
+      build_logger if logger.nil? || log_path
+    end
+
+    attr_accessor :config_file
+    attr_accessor :environment_name
+    attr_accessor :instrument
+    attr_accessor :enabled_environments
+
+    attr_accessor :application_name
+    attr_accessor :hostname
+
+    attr_accessor :log_path
+    attr_accessor :log_level
+    attr_accessor :logger
+
+    attr_accessor :log_trace_path
+    attr_accessor :source_lines_error_app_frames
+    attr_accessor :source_lines_span_app_frames
+    attr_accessor :source_lines_error_library_frames
+    attr_accessor :source_lines_span_library_frames
+    attr_accessor :span_frames_min_duration
+
+    attr_accessor :max_queue_size
+    attr_accessor :flush_interval
+
+    attr_accessor :filter_exception_types
+
+    attr_accessor :debug_transactions
+
+    attr_accessor :disabled_spies
+
+    attr_accessor :view_paths
+    attr_accessor :root_path
+    attr_accessor :http_status
+
+    def app=(app)
+      case app_type?(app)
+      when :rails
+        set_rails(app)
+      else
+        # TODO: define custom?
+        self.application_name = 'ruby'
+      end
+    end
+
+    def app_type?(app)
+      if defined?(::Rails) && app.is_a?(Rails::Application)
+        return :rails
+      end
+      nil
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def available_spies
+      %w[
+        action_dispatch
+        mongo
+        net_http
+        httpclient
+        sinatra
+        tilt
+      ]
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def enabled_spies
+      available_spies - disabled_spies
+    end
+
+    def check_lastlog_needs_new(path)
+      latest_file = Dir.glob("#{path}*").grep(/([#])\w+/).max_by {|f| File.mtime(f)}
+      new_flagger = false
+
+      if latest_file.nil?
+          new_flagger = true
+      else
+        current_kb_size = ((File.size(latest_file)) / 1000).to_f
+
+        #50000KB = 50MB
+        if current_kb_size > 50000.0
+          new_flagger = true
+        end
+      end
+      result = {
+        'latest_file' => latest_file,
+        'new_flagger' => new_flagger
+      }
+
+    end
+
+    private
+
+    def assign(options)
+      options.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def set_defaults
+      assign(DEFAULTS)
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    def set_from_env
+      ENV_TO_KEY.each do |env_key, key|
+        next unless (value = ENV[env_key])
+
+        type, key = key if key.is_a? Array
+
+        value =
+          case type
+          when :int then value.to_i
+          when :float then value.to_f
+          when :bool then !%w[0 false].include?(value.strip.downcase)
+          when :list then value.split(/[ ,]/)
+          else value
+          end
+
+        send("#{key}=", value)
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+
+    def set_from_args(options)
+      assign(options)
+    end
+
+    def set_from_config_file
+      return unless File.exist?(config_file)
+      assign(YAML.load_file(config_file) || {})
+    end
+
+    def set_rails(app) # rubocop:disable Metrics/AbcSize
+      self.application_name ||= format_name(application_name || app.class.parent_name)
+      self.logger ||= Rails.logger
+
+      self.root_path = Rails.root.to_s
+      self.view_paths = app.config.paths['app/views'].existent
+    end
+
+    def build_logger
+      logger = Logger.new(log_path == '-' ? $stdout : log_path)
+      logger.level = log_level
+
+      self.logger = logger
+    end
+
+    def format_name(str)
+      str.gsub('::', '_')
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end