reportsmash 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a6e07dc3c76a8d907d9978bf102f4b8ed9565ee2
+  data.tar.gz: 8270ca13975c6396261d40c033fea7a4152780ca
+SHA512:
+  metadata.gz: c35cb6fb18f52f6ea8db50a09a7edd13681bb8f843c6034ac819a325b38ff650143b2d9891087cfbf0971fe8d4b9c324f47dbc43de88eb2eebfac17e81d968cc
+  data.tar.gz: 8f9b37d5343c76fa8100bbfed9de6999b183c6fa7ba6f893e2800f408f9b9a8302bad599aadcebee274f109e9ba4d4a260f08cb85de58370d003dbee937cd0bb

data/LICENSE

@@ -0,0 +1,34 @@
+Except for components included from external libraries
+All source code of this product is
+Copyright (c) 2015-2016 ReportsMash d.o.o. All rights reserved.
+
+Subject to the terms of this notice, ReportsMash grants you a
+nonexclusive, nontransferable license, without the right to
+sublicense, to (a) install and execute one copy of these files on any
+number of servers owned or controlled by you and (b) distribute
+verbatim copies of these files to third parties.  As a condition to the
+foregoing grant, you must provide this notice along with each copy you
+distribute and you must not remove, alter, or obscure this notice. All
+other use, reproduction, modification, distribution, or other
+exploitation of these files is strictly prohibited, except as may be set
+forth in a separate written license agreement between you and ReportsMash.
+The terms of any such license agreement will control over this notice.  
+The license stated above will be automatically terminated and revoked if 
+you exceed its scope or violate any of the terms of this notice.
+
+This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of ReportsMash, except as
+required for reasonable and customary use in describing the origin of
+this file and reproducing the content of this notice.  You may not
+mark or brand this file with any trade name, trademarks, service
+marks, or product names other than the original brand (if any)
+provided by ReportsMash.
+
+Unless otherwise expressly agreed by ReportsMash in a separate written
+license agreement, these files are provided AS IS, WITHOUT WARRANTY OF
+ANY KIND, including without any implied warranties of MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE, or NON-INFRINGEMENT.  As a
+condition to your use of these files, you are solely responsible for
+such use. ReportsMash will have no liability to you for direct,
+indirect, consequential, incidental, special, or punitive damages or
+for lost profits or data.

data/README.rdoc

@@ -0,0 +1,2 @@
+= ReportsMash
+

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ReportsMash'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/reportsmash/control/class_methods.rb

@@ -0,0 +1,17 @@
+module ReportsMash
+  class Control
+    module ClassMethods
+      def instance(create=true)
+        @instance ||= create && new
+      end
+      
+      # clear out memoized Control and LocalEnv instances
+      def reset
+        @instance = nil
+        @local_env = nil
+      end
+
+    end
+    extend ClassMethods
+  end
+end

data/lib/reportsmash/control/instance_methods.rb

@@ -0,0 +1,70 @@
+module ReportsMash
+  class Control
+    module InstanceMethods
+      attr_writer :env
+      attr_reader :env
+      def init_plugin(options={})
+        # initialize the engine instance
+        ReportsMash::Engine.engine = ReportsMash::Engine::Engine.instance
+        ReportsMash::Engine.options = options
+
+        $stderr.puts "Initializing plugin ReportsMash - #{Process.pid}\n"
+        setup_rack_hooks(options[:config])
+        setup_database_hooks(options[:config], ReportsMash::Engine.engine)
+        setup_render_hooks(options[:config], ReportsMash::Engine.engine)
+
+        # if server is forking (eg, unicorn), we should not start the worker thread here
+        # it will be handled by Engine.transaction_start method
+        ReportsMash::Engine.engine.start_worker unless server_is_forking?
+      end
+
+      def setup_rack_hooks(config)
+          return if config.nil? || !config.respond_to?(:middleware)
+          begin
+            require 'reportsmash/rack/hooks'
+            config.middleware.use ReportsMash::Rack::Hooks
+          rescue => e
+            #::ReportsMash::Engine.logger.warn("Error installing ReportsMash Rack middleware", e)
+          end        
+      end
+
+      def setup_database_hooks(config, engine)
+        ActiveSupport::Notifications.subscribe('sql.active_record') do |name, start, finish, id, payload|
+          unless payload[:name] == 'SCHEMA'
+            engine.save_db_transaction(id, (finish-start)*1000.0, payload[:sql], payload[:connection_id])
+          end
+        end
+      end
+
+      def setup_render_hooks(config, engine)
+        ActiveSupport::Notifications.subscribe('render_template.action_view') do |name, start, finish, id, payload|
+          view_name = payload[:identifier].split('app/views')[1]
+          engine.save_render_transaction(id, (finish-start)*1000.0, 'app/views'+view_name)
+        end
+        ActiveSupport::Notifications.subscribe('render_partial.action_view') do |name, start, finish, id, payload|
+          view_name = payload[:identifier].split('app/views')[1]
+          Rails.logger.debug "#{view_name} - #{(finish-start)*1000.0}"
+          engine.save_render_transaction(id, (finish-start)*1000.0, 'app/views'+view_name)
+        end
+      end
+
+      def server_is_forking?
+        # check for unicorn server
+        return true if defined?(::Unicorn) && defined?(::Unicorn::HttpServer) && object_running?(::Unicorn::HttpServer)
+
+        false
+      end
+
+      def object_running?(o)
+        ObjectSpace.each_object(o) do |exists|
+          return true
+        end
+        return false
+      end
+
+    end
+
+    include InstanceMethods
+  end
+end
+

data/lib/reportsmash/control.rb

@@ -0,0 +1,11 @@
+require 'reportsmash/control/instance_methods'
+require 'reportsmash/control/class_methods'
+require 'reportsmash/engine'
+require 'reportsmash/engine/engine'
+
+module ReportsMash
+  class Control
+  end
+end
+
+

data/lib/reportsmash/engine/engine.rb

@@ -0,0 +1,118 @@
+module ReportsMash
+  module Engine
+    class Engine
+      module ClassMethods
+        def instance
+          @instance ||= self.new
+        end
+      end
+      extend ClassMethods
+      
+      attr_accessor :delivery_queue
+      attr_accessor :pid
+      attr_accessor :collector
+
+      def initialize
+        @transactions = {}
+        @engine_start = Time.now
+        @delivery_queue = []
+        @db_transactions = {}
+        @pid = Process.pid
+        @started = false
+      end
+
+      def boot_from_fork
+        return if @started
+        @started = true
+        @pid = Process.pid
+        @engine_start = Time.now
+
+        $stderr.puts "Initializing plugin ReportsMash in child #{Process.ppid} -> #{Process.pid}\n"
+        begin
+          start_worker
+        rescue => e
+          $stderr.puts "Error while starting worker #{e.inspect}"
+        end
+      end
+
+      def transaction_start(request)
+        if @pid != Process.pid && !@started
+          # we have been forked. Make sure engine worker is running in this child
+          ReportsMash::Engine.boot_from_fork()
+        end
+        transaction = ReportsMash::Engine::Transaction.new(@instance, request)
+        ReportsMash::Engine::ThreadState.get_current_state.transaction = transaction
+        request["X-REPORTSMASH-TRANSACTION-ID"] = transaction.tid
+        @transactions[transaction.tid] = transaction
+      end
+
+      def transaction_end(start_time, stop_time, e, response, env)
+        transaction = @transactions[env["X-REPORTSMASH-TRANSACTION-ID"]]
+        (status_code, headers, body) = response       
+        transaction.end(start_time, stop_time, status_code, headers)
+        # don't allow more than 150 transactions in queue
+        @delivery_queue.push transaction if @delivery_queue.count < 150
+        env.delete("X-REPORTSMASH-TRANSACTION-ID") if env["X-REPORTSMASH-TRANSACTION-ID"]
+        ReportsMash::Engine::ThreadState.clear
+      end
+
+      def custom_attr(new_params)
+        trans = ReportsMash::Engine::ThreadState.get_current_state.transaction
+        trans.user_params.merge!(new_params) if new_params.is_a? Array
+      end
+
+      def start_worker
+        @worker_thread = ReportsMash::Engine::Threading::WorkerThread.new do
+          worker_loop = ReportsMash::Engine::WorkerLoop.new
+          worker_loop.run
+        end
+      end
+
+      def save_db_transaction(id, duration, sql, connection_id)
+        trans = ReportsMash::Engine::ThreadState.get_current_state.transaction
+        return unless trans
+        item = {
+          duration: duration,
+          sql: sql,
+          connection_id: connection_id
+        }
+        trans.db_transactions.push item
+        trans.db_duration_ms += duration
+      end
+
+      def save_render_transaction(id, duration, path)
+        trans = ReportsMash::Engine::ThreadState.get_current_state.transaction
+        return unless trans
+        item = {
+          duration: duration,
+          path: path
+        }
+        trans.render_transactions.push item
+        trans.render_duration_ms += duration
+      end
+
+      def save_external_http(item)
+        trans = ReportsMash::Engine::ThreadState.get_current_state.transaction
+        return unless trans
+        trans.external_http_requests.push item
+        trans.external_http_duration_ms += item[:duration]
+      end
+
+      def save_external_mc(op, duration)
+        trans = ReportsMash::Engine::ThreadState.get_current_state.transaction
+        return unless trans
+        h = {op.to_sym => duration}
+        trans.memcached_ops.push h
+      end
+
+      def save_external_redis(op, duration)
+        trans = ReportsMash::Engine::ThreadState.get_current_state.transaction
+        return unless trans
+        h = {op.to_sym => duration}
+        trans.redis_ops.push h
+      end
+
+    end
+  end
+end
+

data/lib/reportsmash/engine/instrumentation/external.rb

@@ -0,0 +1,16 @@
+module ReportsMash::Engine::Instrumentation
+  module External
+    def self.record_http_trace(data)
+      ReportsMash::Engine.engine.save_external_http(data)
+    end
+
+    def self.record_mc_trace(op, duration)
+      ReportsMash::Engine.engine.save_external_mc(op, duration)
+    end
+
+    def self.record_redis_trace(op, duration)
+      ReportsMash::Engine.engine.save_external_redis(op, duration)
+    end
+
+  end
+end

data/lib/reportsmash/engine/instrumentation/memcache/dalli.rb

@@ -0,0 +1,39 @@
+module ReportsMash::Engine::Instrumentation::Memcache
+	module Dalli
+
+		if defined?(::Dalli) && defined?(::Dalli::Client)
+			::Dalli::Client.class_eval do
+
+	      def reportsmash_mc_get(*args)
+	      	start_time = Time.now
+	      	rv = orig_get(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("get", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_get :get
+	      alias :get :reportsmash_mc_get
+
+	      def reportsmash_mc_set(*args)
+	      	start_time = Time.now
+	      	rv = orig_set(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("set", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_set :set
+	      alias :set :reportsmash_mc_set   
+
+
+	      def reportsmash_mc_get_multi(*args)
+	      	start_time = Time.now
+	      	rv = orig_get_multi(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("get_multi", (Time.now - start_time)*1000.0)
+	      	rv
+	      end
+	      alias :orig_get_multi :get_multi
+	      alias :get_multi :reportsmash_mc_get_multi
+
+	    end
+	  end
+
+	end
+end

data/lib/reportsmash/engine/instrumentation/memcache/mem_cache.rb

@@ -0,0 +1,39 @@
+module ReportsMash::Engine::Instrumentation::Memcache
+	module MemCache
+
+		if defined?(::MemCache)
+			::MemCache.class_eval do
+
+	      def reportsmash_mc_get(*args)
+	      	start_time = Time.now
+	      	rv = orig_get(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("get", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_get :get
+	      alias :get :reportsmash_mc_get
+
+	      def reportsmash_mc_set(*args)
+	      	start_time = Time.now
+	      	rv = orig_set(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("set", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_set :set
+	      alias :set :reportsmash_mc_set   
+
+
+	      def reportsmash_mc_get_multi(*args)
+	      	start_time = Time.now
+	      	rv = orig_get_multi(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("get_multi", (Time.now - start_time)*1000.0)
+	      	rv
+	      end
+	      alias :orig_get_multi :get_multi
+	      alias :get_multi :reportsmash_mc_get_multi
+
+	    end
+	  end
+
+	end
+end

data/lib/reportsmash/engine/instrumentation/memcache/memcached.rb

@@ -0,0 +1,48 @@
+module ReportsMash::Engine::Instrumentation::Memcache
+	module Memcached
+
+		if defined?(::Memcached) && Gem::Version.new("1.8.0") <= Gem::Version.new(::Memcached::VERSION)
+			::Memcached.class_eval do
+
+	      def reportsmash_mc_single_get(*args)
+	      	start_time = Time.now
+	      	rv = orig_single_get(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("get", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_single_get :single_get
+	      alias :single_get :reportsmash_mc_single_get
+
+	      def reportsmash_mc_multi_get(*args)
+	      	start_time = Time.now
+	      	rv = orig_multi_get(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("get_multi", (Time.now - start_time)*1000.0)
+	      	rv
+	      end
+	      alias :orig_multi_get :multi_get
+	      alias :multi_get :reportsmash_mc_multi_get
+
+
+	      def reportsmash_mc_single_cas(*args)
+	      	start_time = Time.now
+	      	rv = orig_single_cas(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("set", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_single_cas :single_cas
+	      alias :single_cas :reportsmash_mc_single_cas
+
+	      def reportsmash_mc_multi_cas(*args)
+	      	start_time = Time.now
+	      	rv = orig_multi_cas(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_mc_trace("set", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_multi_cas :multi_cas
+	      alias :multi_cas :reportsmash_mc_multi_cas
+
+	    end
+	  end
+
+	end
+end

data/lib/reportsmash/engine/instrumentation/memcache.rb

@@ -0,0 +1,7 @@
+module ReportsMash
+  module Engine
+    module Instrumentation
+    	module Memcache
+    end
+  end
+end

data/lib/reportsmash/engine/instrumentation/redis.rb

@@ -0,0 +1,28 @@
+module ReportsMash::Engine::Instrumentation
+	module Redis
+	
+		if defined?(::Redis)
+		  ::Redis.class_eval do
+
+	      def reportsmash_redis_get(*args)
+	      	start_time = Time.now
+	      	rv = orig_get(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_redis_trace("get", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_get :get
+	      alias :get :reportsmash_redis_get
+
+	      def reportsmash_redis_set(*args)
+	      	start_time = Time.now
+	      	rv = orig_set(*args)
+	      	ReportsMash::Engine::Instrumentation::External.record_redis_trace("set", (Time.now - start_time)*1000.0)
+	        rv
+	      end
+	      alias :orig_set :set
+	      alias :set :reportsmash_redis_set
+	      
+	    end
+		end
+	end
+end

data/lib/reportsmash/engine/instrumentation/typhoeus.rb

@@ -0,0 +1,22 @@
+module ReportsMash::Engine::Instrumentation
+	SUPPORTED_VERSION = "0.5.3"
+	if defined?(::Typhoeus) && defined?(::Typhoeus::VERSION) && Gem::Version.new(SUPPORTED_VERSION) <= Gem::Version.new(::Typhoeus::VERSION)
+	  Typhoeus.before do |request|
+	    #start trace
+	    start_time = Time.now
+			cb = Proc.new do
+				duration = (Time.now - start_time)*1000.0
+				data = {
+					client: "Typhoeus",
+					duration: duration,
+					response_code: request.response.response_code,
+					url: request.url,
+					method: request.original_options[:method].to_s.upcase
+				}
+				ReportsMash::Engine::Instrumentation::External.record_http_trace(data)
+			end
+			request.on_complete.unshift(cb)
+			true
+		end
+	end
+end

data/lib/reportsmash/engine/instrumentation.rb

@@ -0,0 +1,6 @@
+module ReportsMash
+  module Engine
+    module Instrumentation
+    end
+  end
+end

data/lib/reportsmash/engine/thread_state.rb

@@ -0,0 +1,19 @@
+module ReportsMash
+  module Engine
+    class ThreadState
+      attr_accessor :transaction
+        def initialize
+          @transaction = nil
+        end
+
+        def self.get_current_state
+          Thread.current[:reportsmash_state] ||= ThreadState.new
+        end
+
+        def self.clear
+          Thread.current[:reportsmash_state] = nil
+        end
+    end
+  end
+end
+

data/lib/reportsmash/engine/threading.rb

@@ -0,0 +1,13 @@
+module ReportsMash
+  module Engine
+    module Threading
+
+      class WorkerThread < ::Thread
+        def initialize
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/reportsmash/engine/transaction.rb

@@ -0,0 +1,116 @@
+module ReportsMash::Engine
+  class Transaction
+    attr_accessor :user_params
+    attr_accessor :payload
+    attr_accessor :db_transactions, :db_duration_ms, :render_transactions, :render_duration_ms
+    attr_accessor :external_http_requests, :external_http_duration_ms
+    attr_accessor :memcached_ops, :redis_ops
+
+    def initialize(engine, request)
+      @engine = engine
+      @request = request
+      @response = nil
+      @tid = SecureRandom.uuid
+      @user_params = []
+      @start_time = nil
+      @total_duration_ms = 0
+      @db_duration_ms = 0
+      @render_duration_ms = 0
+      @payload = {}
+      @db_transactions = []
+      @render_transactions = []
+      @external_http_requests = []
+      @external_http_duration_ms = 0
+      @memcached_ops = []
+      @redis_ops = []
+    end
+
+    def tid
+      @tid
+    end   
+
+    def add_user_params(new_params)
+      @user_params.merge!(new_params) if new_params.is_a? Hash
+    end
+ 
+    def end(start_time, stop_time, status_code, headers)
+      @start_time = start_time
+      response_content_type = (headers && headers["Content-Type"]) ? headers["Content-Type"] : ""
+      @total_duration_ms = (stop_time - start_time) * 1000.0
+      path_params = @request["action_dispatch.request.path_parameters"]
+      controller_action = "static_file_server"
+      if path_params.key?(:controller) && path_params.key?(:action)
+        controller_action = path_params[:controller]+"#"+path_params[:action]
+      end
+
+      @memcached_stats = {}
+      mc_duration_ms = 0
+      mc_counter = 0
+      if @memcached_ops.count > 0
+        %w[get set get_multi].each do |op|
+          stat = {count: 0, duration_ms: 0, avg_ms: 0}
+          @memcached_ops.select{|h| h.key? op.to_sym}.each do |trace|
+            stat[:count] += 1
+            stat[:duration_ms] += trace[op.to_sym]
+            stat[:avg_ms] = (stat[:duration_ms]/Float(stat[:count])).round(2)
+            @memcached_stats[op.to_sym] = stat
+            mc_duration_ms += stat[:duration_ms]
+            mc_counter += 1
+          end
+        end
+        #puts "GOT MC_OPS #{@memcached_ops.inspect}: #{@memcached_stats.inspect}"
+      end
+
+      @redis_stats = {}
+      redis_duration_ms = 0
+      redis_counter = 0
+      if @redis_ops.count > 0
+        %w[get set].each do |op|
+          stat = {count: 0, duration_ms: 0, avg_ms: 0}
+          @redis_ops.select{|h| h.key? op.to_sym}.each do |trace|
+            stat[:count] += 1
+            stat[:duration_ms] += trace[op.to_sym]
+            stat[:avg_ms] = (stat[:duration_ms]/Float(stat[:count])).round(2)
+            @redis_stats[op.to_sym] = stat
+            redis_duration_ms += stat[:duration_ms]
+            redis_counter += 1
+          end
+        end
+        #puts "GOT REDIS_OPS #{@redis_ops.inspect}: #{@redis_stats.inspect}"
+      end
+
+      @payload = {
+        :time_utc => @start_time.utc.to_i,
+        :user_ip => @request["REMOTE_ADDR"],
+        :user_agent => @request["HTTP_USER_AGENT"],
+        :method => @request["REQUEST_METHOD"],
+        :http_host => @request["HTTP_HOST"],
+        :request_uri => @request["REQUEST_URI"],
+        :request_path => @request["REQUEST_PATH"],
+        :controller_action => controller_action,
+        :response_content_type => response_content_type,
+        :status => status_code,
+        :total_duration_ms => @total_duration_ms.round(2),
+        :db_duration_ms => @db_duration_ms.round(2),
+        :render_duration_ms => @render_duration_ms.round(2),
+        :external_http_duration_ms => @external_http_duration_ms.round(2),
+        :external_memcache_duration_ms => mc_duration_ms.round(2),
+        :external_redis_duration_ms => redis_duration_ms.round(2),
+        :db_counter => @db_transactions.count,
+        :render_counter => @render_transactions.count,
+        :external_http_counter => @external_http_requests.count,
+        :external_memcache_counter => mc_counter,
+        :external_redis_counter => redis_counter,
+        :db_transactions => @db_transactions,
+        :render_transactions => @render_transactions,
+        :external_http_requests => @external_http_requests,
+        :external_memcache_requests => @memcached_stats,
+        :external_redis_requests => @redis_stats,
+        
+        :custom_attributes => @user_params
+      }
+    end
+  end
+
+end
+