tracebin 0.0.7

data/lib/vizsla/patches/mysql2.rb

@@ -0,0 +1,22 @@
+::Mysql2::Client.class_eval do
+  alias_method :query_without_vizsla, :query
+
+  def query(*args, &block)
+    start_time   = Time.now
+    result       = query_without_vizsla(*args, &block)
+    end_time     = Time.now
+
+    event_data = [
+      'sql.mysql2_query',
+      start_time,
+      end_time,
+      {
+        sql: args[0]
+      }
+    ]
+
+    ::Vizsla::Patches.handle_event :mysql2, event_data
+
+    result
+  end
+end

data/lib/vizsla/patches/postgres.rb

@@ -0,0 +1,42 @@
+::PG::Connection.class_eval do
+  alias_method :exec_without_vizsla, :exec
+  alias_method :exec_params_without_vizsla, :exec_params
+
+  def exec_params(*args, &block)
+    start_time   = Time.now
+    result       = exec_params_without_vizsla(*args, &block)
+    end_time     = Time.now
+
+    event_data = [
+      'sql.postgres_exec',
+      start_time,
+      end_time,
+      {
+        sql: args[0]
+      }
+    ]
+
+    ::Vizsla::Patches.handle_event :postgres, event_data
+
+    result
+  end
+
+  def exec(*args, &block)
+    start_time   = Time.now
+    result       = exec_without_vizsla(*args, &block)
+    end_time     = Time.now
+
+    event_data = [
+      'sql.postgres_exec',
+      start_time,
+      end_time,
+      {
+        sql: args[0]
+      }
+    ]
+
+    ::Vizsla::Patches.handle_event :postgres, event_data
+
+    result
+  end
+end

data/lib/vizsla/patches/sidekiq_health.rb

@@ -0,0 +1,27 @@
+require 'vizsla/patches'
+require 'vizsla/system_health_sample'
+require 'concurrent'
+
+require 'sidekiq/launcher'
+
+::Sidekiq::Launcher.class_eval do
+  alias_method :run_without_vizsla, :run
+  alias_method :stop_without_vizsla, :stop
+
+  def run
+    @vizsla_task = Concurrent::TimerTask.new(execution_interval: 10) do
+      health = Vizsla::SystemHealthSample.new process: :worker
+      ::Vizsla::Patches.handle_event :sidekiq_health, health
+    end
+
+    @vizsla_task.execute
+
+    run_without_vizsla
+  end
+
+  def stop
+    @vizsla_task.shutdown
+
+    stop_without_vizsla
+  end
+end

data/lib/vizsla/patches/sinatra.rb

@@ -0,0 +1,21 @@
+::Sinatra::Base.class_eval do
+  alias_method :dispatch_without_vizsla!, :dispatch!
+
+  def dispatch!(*args, &block)
+    start_time = Time.now
+    result = dispatch_without_vizsla!(*args, *block)
+    end_time = Time.now
+    route = env['sinatra.route']
+
+    event_data = [
+      'sinatra.route_exec',
+      start_time,
+      end_time,
+      route
+    ]
+
+    ::Vizsla::Patches.handle_event :sinatra, event_data
+
+    result
+  end
+end

data/lib/vizsla/patches.rb

@@ -0,0 +1,44 @@
+require 'vizsla/helpers'
+
+module Vizsla
+  ##
+  # This singleton class handles patching for any given library we wish to
+  # instrument. To create a new patch for a library, just create a file in the
+  # +lib/patches+ directory with any name. These files typically contain code
+  # that will monkeypatch a given library. When you wish to execute the code
+  # in that file, just call its corresponding +patch_+ method. For example, if
+  # we have a file +lib/patches/foo.rb+, then we would just call:
+  #
+  #   ::Vizsla::Patches.patch_foo
+  #
+  class Patches
+    include ::Vizsla::Helpers
+
+    PATCH_METHOD_REGEX = /^patch_(.*)$/
+
+    class << self
+      def handle_event(handler_name, event_data)
+        handler = instance_variable_get "@#{handler_name}_event_handler"
+        handler.call event_data unless handler.nil?
+      end
+
+      def method_missing(method_sym, *args, &block)
+        if method_sym.to_s =~ PATCH_METHOD_REGEX
+          patch_name = $1
+          instance_variable_set "@#{patch_name}_event_handler", block
+          require "vizsla/patches/#{patch_name}"
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_sym, include_private = false)
+        if method_sym.to_s =~ PATCH_METHOD_REGEX
+          true
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/vizsla/puppet_master.rb

@@ -0,0 +1,17 @@
+require 'vizsla/logger'
+require 'vizsla/reporter'
+
+module Vizsla
+  class PuppetMaster
+    def initialize(puppet, options = {})
+      @puppet = puppet
+      @logger = RequestLogger.new(options[:logger])
+      @storage = ::Vizsla::Agent.storage
+    end
+
+    def process
+      # @logger.display_payload @puppet.payload
+      @storage << @puppet.payload
+    end
+  end
+end

data/lib/vizsla/recorder.rb

@@ -0,0 +1,43 @@
+module Vizsla
+  class Recorder
+    THREAD_LOCAL_KEY = :_vizsla_current
+    LOCK = Mutex.new
+
+    class << self
+      def current
+        LOCK.synchronize do
+          Thread.current[THREAD_LOCAL_KEY]
+        end
+      end
+
+      def current=(val)
+        Thread.current[THREAD_LOCAL_KEY] = val
+      end
+
+      def start_recording
+        self.current = {}
+      end
+
+      def recording?
+        !self.current.nil?
+      end
+
+      def add_event(event)
+        return unless self.recording?
+        self.current[:events] ||= []
+        self.current[:events] << event.data_hash
+      end
+      alias_method :<<, :add_event
+
+      def events
+        self.current[:events]
+      end
+
+      def stop_recording
+        LOCK.synchronize do
+          Thread.current[THREAD_LOCAL_KEY] = nil
+        end
+      end
+    end
+  end
+end

data/lib/vizsla/reporter.rb

@@ -0,0 +1,74 @@
+require 'net/http'
+require 'json'
+require 'concurrent'
+
+module Vizsla
+  class Reporter
+    attr_reader :logger, :config, :storage
+
+    def initialize(storage = Vizsla::Agent.storage, config = Vizsla::Agent.config, logger = Vizsla::Agent.logger)
+      @logger = logger
+      @config = config
+      @storage = storage
+
+      host = Vizsla::Agent.config.host
+      path = Vizsla::Agent.config.report_path
+      @uri = URI("#{host}/#{path}")
+
+      @bin_id = Vizsla::Agent.config.bin_id
+    end
+
+    def start!
+      @task = Concurrent::TimerTask.new do
+        unless storage.unloaded?
+          payload = storage.unload
+          res = send_data payload
+
+          handle_response res, payload
+        end
+      end
+
+      logger.info 'TRACEBIN: Reporter starting.'
+      @task.execute
+    end
+
+    def stop!
+      logger.info 'TRACEBIN: Reporter stopping. The agent will no longer report metrics to the server.'
+      @task.shutdown if @task && @task.running?
+    end
+
+    private
+
+    def send_data(payload)
+      logger.info 'TRACEBIN: Sending analytics data to the server.'
+
+      Net::HTTP.start(@uri.host, @uri.port) do |http|
+        body = {
+          bin_id: @bin_id,
+          report: payload
+        }.to_json
+
+        req = Net::HTTP::Post.new @uri
+        req.content_type = 'application/json'
+        req.body = body
+
+        http.request req
+      end
+    rescue Exception => e
+      logger.warn "TRACEBIN: Exception occurred sending data to the server: #{e.message}"
+    end
+
+    def handle_response(res, payload)
+      case res
+      when Net::HTTPSuccess
+        logger.info 'TRACEBIN: Successfully sent payload to the server.'
+      when Net::HTTPBadRequest
+        logger.warn 'TRACEBIN: App bin ID not found. Please create a new app bin and add it to the config.'
+        self.stop!
+      else
+        logger.warn 'TRACEBIN: Failed to send data to the server. Will try again in 1 minute.'
+        @storage.add_payload payload
+      end
+    end
+  end
+end

data/lib/vizsla/storage.rb

@@ -0,0 +1,30 @@
+require 'concurrent'
+
+module Vizsla
+  class Storage
+    attr_reader :values
+
+    def initialize
+      @values = Concurrent::Array.new
+    end
+
+    def add(payload)
+      @values << payload
+    end
+    alias_method :<<, :add
+
+    def add_payload(payload)
+      @values += payload if payload.is_a?(Array)
+    end
+
+    def unload
+      duplicate_values = @values.dup
+      @values.clear
+      duplicate_values
+    end
+
+    def unloaded?
+      @values.empty?
+    end
+  end
+end

data/lib/vizsla/subscribers.rb

@@ -0,0 +1,172 @@
+require 'vizsla/recorder'
+require 'vizsla/patches'
+require 'vizsla/events'
+require 'vizsla/background_job_instrumentation'
+
+module Vizsla
+  ##
+  # Subscribes to certain events, handels them, and passes event data to the
+  # +Recorder+ class. The general workflow goes like this:
+  #
+  # 1. Patch the method you want to profile. It should generate an array that
+  # looks like the following:
+  #
+  #   [
+  #     "event_type.event_domain",
+  #     start_time,
+  #     stop_time,
+  #     etc...,
+  #     { event: :data }
+  #   ]
+  #
+  # Note that the event hash must be the last element in the array (this is to
+  # maintain consistency with ActiveSupport::Notifications).
+  #
+  # 2. Store that event array into an appropriate +Event+ subclass.
+  # 3. Add each +Event+ object to +@events_data+ using the +#<<+ method.
+  #
+  class Subscribers
+    def initialize
+      @events_data = Recorder
+      collect_events_data
+    end
+
+    private
+
+    def collect_events_data
+      if rails_app?
+        rails_hooks
+      else
+        other_hooks
+      end
+
+      background_job_hooks
+    end
+
+    def rails_hooks
+      sql_hook
+      process_action_hook
+      render_layout_hook
+      render_template_hook
+      render_partial_hook
+    end
+
+    def other_hooks
+      sinatra_hook if sinatra_app?
+      db_hooks
+      background_job_hooks
+    end
+
+    def background_job_hooks
+      if defined? ::ActiveJob
+        active_job_hook
+      else
+        sidekiq_hook
+        resque_hook
+      end
+    end
+
+    def db_hooks
+      postgres_hook
+      mysql2_hook
+    end
+
+    # ===---------------------------===
+    # Rails Hooks
+    # ===---------------------------===
+
+    def sql_hook
+      subscribe_asn 'sql.active_record', SQLEvent
+    end
+
+    def process_action_hook
+      subscribe_asn 'process_action.action_controller', ControllerEvent
+    end
+
+    def render_layout_hook
+      unless [ActionPack::VERSION::MAJOR, ActionPack::VERSION::MINOR] == [3, 0]
+        ::Vizsla::Patches.patch_action_view_layout do |event_data|
+          event = ViewEvent.new event_data
+          @events_data << event
+        end
+      end
+    end
+
+    def render_template_hook
+      subscribe_asn 'render_template.action_view', ViewEvent
+    end
+
+    def render_partial_hook
+      subscribe_asn 'render_partial.action_view', ViewEvent
+    end
+
+    def active_job_hook
+      ::Vizsla::BackgroundJobInstrumentation.install :active_job
+    end
+
+    # ===---------------------------===
+    # DB Hooks
+    # ===---------------------------===
+
+    def postgres_hook
+      return unless defined? ::PG
+      ::Vizsla::Patches.patch_postgres do |event_data|
+        event = SQLEvent.new event_data
+        @events_data << event
+      end
+    end
+
+
+    def mysql2_hook
+      return unless defined? ::Mysql2
+      ::Vizsla::Patches.patch_mysql2 do |event_data|
+        event = SQLEvent.new event_data
+        @events_data << event
+      end
+    end
+
+    # ===---------------------------===
+    # Background Job Hooks
+    # ===---------------------------===
+
+    def sidekiq_hook
+      return unless defined? ::Sidekiq
+      ::Vizsla::BackgroundJobInstrumentation.install :sidekiq
+    end
+
+    def resque_hook
+      return unless defined? ::Resque
+      ::Vizsla::BackgroundJobInstrumentation.install :resque
+    end
+
+    # ===---------------------------===
+    # Sinatra Hooks
+    # ===---------------------------===
+
+    def sinatra_hook
+      ::Vizsla::Patches.patch_sinatra do |event_data|
+        event = SinatraEvent.new event_data
+        @events_data << event
+      end
+    end
+
+    # ===---------------------------===
+    # Aux
+    # ===---------------------------===
+
+    def subscribe_asn(event_name, event_klass)
+      ActiveSupport::Notifications.subscribe event_name do |*args|
+        event = event_klass.new args
+        @events_data << event if event.valid?
+      end
+    end
+
+    def rails_app?
+      defined? ::Rails
+    end
+
+    def sinatra_app?
+      defined? ::Sinatra
+    end
+  end
+end

data/lib/vizsla/system_health_sample.rb

@@ -0,0 +1,187 @@
+module Vizsla
+  class SystemHealthSample
+    DATA_TYPE = 'system_health_sample'.freeze
+
+    def initialize(options = {})
+      @process = options[:process] || :web
+      @sampled_at = Time.new
+      @metrics = sample_metrics
+    end
+
+    def payload
+      {
+        type: DATA_TYPE,
+
+        data: {
+          sampled_at: @sampled_at,
+
+          metrics: @metrics
+        }
+      }
+    end
+
+    private
+
+    def sample_metrics
+      {
+        process: @process.to_s,
+        cpu: processor_info,
+        memory: mem_info,
+        disks: disk_info,
+        machine_id: machine_info
+      }
+    end
+
+    def ruby_os_identifier
+      RbConfig::CONFIG['target_os']
+    end
+
+    def darwin?
+      !!(ruby_os_identifier =~ /darwin/i)
+    end
+
+    def linux?
+      !!(ruby_os_identifier =~ /linux/i)
+    end
+
+    def machine_info
+      ip_string = `dig +short myip.opendns.com @resolver1.opendns.com`.strip
+      hostname = `hostname`.strip
+
+      kernel = nil
+
+      if darwin?
+        kernel = 'darwin'
+      elsif linux?
+        kernel = 'linux'
+      end
+
+      {
+        hostname: hostname,
+        ip: ip_string,
+        kernel: kernel
+      }
+    end
+
+    def disk_info(disks = ["disk0"])
+      if darwin?
+        read_iostat(disks)
+      elsif linux?
+        parse_proc
+      end
+    end
+
+    def parse_proc
+      {
+        load_average: `cat /proc/loadavg | awk '{print $1,$2,$3}'`.strip
+      }
+    end
+
+    def read_iostat(disks)
+      disks_info = {}
+      captured_data = []
+
+      disks.each do |disk|
+        disk_data = `iostat -Ud #{disk}`.strip.split(/\n/)
+        captured_data << disk_data
+        disks_info["load_average"] = disk_data.last.strip.split(/\s+/)[3..-1].map(&:to_f) unless disks_info["load_average"]
+      end
+
+      captured_data.each_with_index do |disk, index|
+        disk_name = disks[index]
+        disk_stats = disk.last.strip.split(/\s+/)[0, 3]
+        disks_info[disk_name] = {
+          kb_per_trans: disk_stats[0].to_f,
+          trans_num: disk_stats[1].to_f,
+          mb_per_sec: disk_stats[2].to_f
+        }
+      end
+      disks_info
+    end
+
+    def mem_info
+      if darwin?
+        total, wired, free, used = get_mach_memory_stats
+        return {
+          total_memory: total,
+          wired_memory: wired,
+          free_memory: free,
+          used_memory: used
+        }
+      elsif linux?
+        total, cache, free, used, available = get_linux_memory_stats
+        return {
+          total_memory: total,
+          wired_memory: cache,
+          free_memory: free,
+          used_memory: used,
+          available_memory: available
+        }
+      end
+    end
+
+    def get_mach_memory_stats
+      used, wired, free = `top -l 1 -s 0 | grep PhysMem`.scan(/\d+/)
+      total = `sysctl -n hw.memsize`.to_i / 1024 / 1024
+      [total.to_i, wired.to_i, free.to_i, used.to_i]
+    end
+
+    def get_linux_memory_stats
+      total, used, free, _, cache, available = `free | grep Mem`.scan(/\d+/).map { |mem_stat| mem_stat.to_i / 1024 }
+      [total.to_s, cache.to_s, free.to_s, used.to_s, available.to_s]
+    end
+
+    def processor_info
+      info = {}
+
+      if darwin?
+        info[:model_name] = get_sysctl_value('machdep.cpu.brand_string')
+        info[:processor_count] = get_sysctl_value('hw.packages').to_i
+        info[:core_count] = get_sysctl_value('hw.physicalcpu_max').to_i,
+        info[:logical_cpu_count] = get_sysctl_value('hw.logicalcpu_max').to_i
+      elsif linux?
+        proc_string = read_proc('/proc/cpuinfo')
+        info = parse_proc_cpuinfo_string(proc_string)
+      end
+      info
+    end
+
+    def get_sysctl_value(key)
+      `sysctl -n #{key} 2>/dev/null`
+    end
+
+    def read_proc(path)
+      return nil unless File.exist? path
+      `cat #{path} 2>/dev/null`
+    end
+
+    def parse_proc_cpuinfo_string(proc_string)
+      threads = proc_string.split(/\n\n/).map { |core| core.split(/\n/) }
+
+      units = {}
+      cores = {}
+      model_name = nil
+
+      threads.each do |thread|
+        thread.each do |line|
+          if matched_line = line.match(/physical\ id\s*\:\s*(\d)/i)
+            id = matched_line[1]
+            units[id] = true
+          elsif matched_line = line.match(/core\ id\s*\:\s*(\d)/i)
+            id = matched_line[1]
+            cores[id] = true
+          elsif matched_line = line.match(/model\ name\s*\:\s*(.*)/i)
+            model_name = matched_line[1] unless model_name
+          end
+        end
+      end
+
+      {
+        model_name: model_name,
+        processor_count: units.count,
+        core_count: cores.count,
+        logical_cpu_count: threads.count
+      }
+    end
+  end
+end