d13n 0.5.2

data/lib/d13n/logger.rb

@@ -0,0 +1,213 @@
+# encoding: utf-8
+#require 'd13n/api/operation_state'
+require 'logger'
+require 'singleton'
+require 'd13n/logger/log_once'
+require 'd13n/logger/memory_logger'
+require 'd13n/logger/null_logger'
+module D13n
+  class Logger
+    class SilenceLogger
+      def fatal(*args); end
+      def error(*args); end
+      def warn(*args);  end
+      def info(*args);  end
+      def debug(*args); end
+
+      def method_missing(method, *args, &blk)
+        nil
+      end
+    end
+
+    def initialize(root="STDOUT", override_logger=nil)
+      @root = root
+      
+      create_logger(@root, override_logger)
+      set_log_level!
+      set_log_format!
+      
+      gather_startup_logs
+    end
+
+    def info(*msgs, &blk)
+      format_and_send(:info, msgs, &blk)
+    end
+
+    def warn(*msgs, &blk)
+      format_and_send(:warn, msgs, &blk)
+    end
+
+    def error(*msgs, &blk)
+      format_and_send(:error, msgs, &blk)
+    end
+
+    def fatal(*msgs, &blk)
+      format_and_send(:fatal, msgs, &blk)
+    end
+
+    def debug(*msgs, &blk)
+      format_and_send(:debug, msgs, &blk)
+    end
+
+    def log_formatter=(formatter)
+      @log.formatter = formatter
+    end
+
+    def log_exception(level, e, backtrace_level=level)
+      @log.send(level, "%p: %s" % [ e.class, e.message ])
+      @log.send(backtrace_level) do
+        backtrace = backtrace_from_exception(e)
+        if backtrace
+          "Debugging backtrace:\n" + backtrace.join("\n  ")
+        else
+          "No backtrace available."
+        end
+      end
+    end
+
+    def formatter
+      @log.formatter
+    end
+
+    private
+
+    def backtrace_from_exception(e)
+      return caller.drop(5) if e.is_a?(SystemStackError)
+
+      e.backtrace
+    end
+
+    def find_or_create_file_path(path_setting, root)
+      for abs_path in [ File.expand_path(path_setting),
+                        File.expand_path(File.join(root, path_setting)) ] do
+        if File.directory?(abs_path) || (Dir.mkdir(abs_path) rescue nil)
+          return abs_path[%r{^(.*?)/?$}]
+        end
+      end
+      nil
+    end
+
+    def format_and_send(level, *msgs, &block)
+      if block
+        if @log.send("#{level}?")
+          msgs = Array(block.call)
+        else
+          msgs = []
+        end
+      end
+
+      msgs.flatten.each do |item|
+        case item
+        when Exception then log_exception(level, item, :debug)
+        else @log.send(level, item)
+        end
+      end
+      nil
+    end
+    
+    LOG_LEVELS = {
+        "debug" => ::Logger::DEBUG,
+        "info"  => ::Logger::INFO,
+        "warn"  => ::Logger::WARN,
+        "error" => ::Logger::ERROR,
+        "fatal" => ::Logger::FATAL,
+    }
+
+    def self.log_level_for(level)
+        LOG_LEVELS.fetch(level.to_s.downcase, ::Logger::INFO)
+    end
+
+    def set_log_level!
+        @log.level = self.class.log_level_for(::D13n.config[:log_level])
+    end
+
+    def log_stdout?
+      D13n.config[:log_file_path].upcase == "STDOUT"
+    end
+
+    def create_log_to_file(root)
+      path = find_or_create_file_path(::D13n.config[:log_file_path], root)
+      if path.nil?
+        @log = ::Logger.new(STDOUT)
+        warn("Error creating log directory #{::D13n.config[:log_file_path]}, using standard out for logging.")
+      else
+        file_path = "#{path}/#{::D13n.config[:log_file_name]}"
+        begin
+          @log = ::Logger.new(file_path)
+        rescue => e
+          @log = ::Logger.new(STDOUT)
+          warn("Failed creating logger for file #{file_path}, using standard out for logging.", e)
+        end
+      end
+    end
+
+    def create_logger(root,override_logger)
+      if !override_logger.nil?
+        @log = override_logger
+      elsif ::D13n.config[:log_level] == :silence
+        create_silence_logger
+      else
+        if log_stdout?
+          @log = ::Logger.new(STDOUT)
+        else
+          create_log_to_file(root)
+        end
+      end
+    end
+
+    def set_log_format!
+      @prefix = log_stdout? ? "** [#{D13n.config[:app_name].capitalize}]" : ''
+      @log.formatter = 
+      if log_format == 'json'
+        Proc.new do |severity, timestamp, progname, msg|
+          log_data = tag_hash.merge({
+            app: D13n.config.app_name,
+            ts: timestamp.strftime("%F %H:%M:%S %z"),
+            pid: $$,
+            severity: severity,
+            request_id: request_id
+          })
+          if msg.respond_to?(:to_hash)
+            log_data.merge!(msg.to_hash)
+          else
+            log_data.merge!({message: msg})
+          end 
+          "#{log_data.to_json}\n"
+        end
+      else
+        Proc.new do |severity, timestamp, progname, msg|
+          "#{@prefix}[#{timestamp.strftime("%F %H:%M:%S %z")} (#{$$})] #{severity} #{request_id} : #{msg}\n"
+        end
+      end
+    end
+
+    def log_format
+      ::D13n.config[:log_format]
+    end
+
+    def state
+      D13n::Metric::StreamState.st_get
+    end
+    
+    def request_id
+      @request_info = state.request_info || {}
+      @request_info['request_id'] || '-'
+    end
+
+    def tag_hash
+      state.tag_hash || {}
+    end
+
+    def create_silence_logger
+      @log = SilenceLogger.new
+    end
+
+    def gather_startup_logs
+      StartupLogger.instance.dump(self)
+    end
+
+    class StartupLogger < MemoryLogger
+      include Singleton
+    end
+  end
+end

data/lib/d13n/metric/conductor.rb

@@ -0,0 +1,123 @@
+require 'd13n/metric'
+module D13n::Metric::Instrumentation
+  module Conductor
+    module_function
+    @concerts = []
+
+    def direct(&block)
+      concert = Performance.new
+      concert.instance_eval(&block)
+
+      if concert.name
+        seen_names = @concerts.map { |c| c.name }.compact
+        if seen_names.include?(concert.name)
+          D13n.logger.warn("Refusing to re-register Performance block with name '#{concert.name}'")
+          return @concerts
+        end
+      end
+
+      @concerts << concert
+    end
+
+    def perform!
+      @concerts.each do |concert|
+        if concert.ready?
+          concert.perform
+        end
+      end
+    end
+
+    def concert_by_name(name)
+      @concerts.find { |c| c.name == name }
+    end
+
+    def performed?(name)
+      concert = concert_by_name(name)
+      concert && concert.performed
+    end
+
+    def concerts
+      @concerts
+    end
+
+    def concerts=(new_concerts)
+      @concerts = new_concerts
+    end
+
+    def clear
+      @concerts = []
+    end
+
+    class Performance
+      attr_reader :performed
+      attr_accessor :name
+
+      def perform!
+        @performed = true
+      end
+
+      attr_reader :dependences
+
+      def initialize
+        @dependences = []
+        @performances = []
+        @name = nil
+      end
+
+      def ready?
+        !performed and check_dependences
+      end
+
+      def perform
+        @performances.each do |p|
+          begin
+            p.call
+          rescue => e
+            D13n.logger.error("Error while setting up #{self.name} instrumentation:", e)
+            break
+          end
+        end
+      ensure
+        perform!
+      end
+
+      def depend_on
+        @dependences << Proc.new
+      end
+
+      def check_dependences
+        return false unless allowed_by_config? && dependences
+
+        dependences.all? do |score|
+          begin
+            score.call
+          rescue => e
+            D13n.logger.error("Error while checking #{self.name}:", e)
+            false
+          end
+        end
+      end
+
+      def allowed_by_config?
+        return true if self.name.nil?
+
+        key = "instrumentation.#{self.name}.disable".to_sym
+
+        if (D13n.config[key] == true)
+          D13n.logger.debug("Not setting up #{self.name} instrumentation for configuration #{key}")
+          false
+        else
+          true
+        end
+      end
+
+      def named(new_name)
+        self.name = new_name
+      end
+
+      def performances
+        @performances << Proc.new
+      end
+    end
+  end
+end

data/lib/d13n/metric/helper.rb

@@ -0,0 +1,62 @@
+module D13n::Metric
+  module Helper
+    def self.http_request_for(app_name, direction)
+      downcase_direction = direction.to_s.downcase
+      check_direction(downcase_direction)
+      scope ||= []
+      scope << D13n.idc_name
+      scope << D13n.app_name.downcase
+      scope << D13n.idc_env
+      scope << 'http'
+      scope << downcase_direction
+      scope
+    end
+
+    def self.http_request_count_for(service, direction)
+      scope = http_request_for(service, direction)
+      scope << "count"
+      scope.join('.')
+    end
+
+    def self.http_request_timing_for(service, direction)
+      scope = http_request_for(service, direction)
+      scope << "timing"
+      scope.join('.')
+    end
+
+    def self.http_in_tracable?
+      D13n.config[:'metric.app.http.in.tracable'] == 'true' || D13n.config[:'metric.app.http.in.tracable'] == true
+    end
+
+    def self.http_out_tracable?
+      D13n.config[:'metric.app.http.out.tracable'] == 'true' || D13n.config[:'metric.app.http.out.tracable'] == true
+    end
+
+    def self.db_tracable?
+      D13n.config[:'metric.app.db.tracable'] == 'true' || D13n.config[:'metric.app.db.tracable'] == true
+    end
+
+    def self.biz_tracable?
+      D13n.config[:'metric.business.state.tracable'] == 'true' || D13n.config[:'metric.business.state.tracable'] == true
+    end
+
+    def self.exception_tracable?
+      D13n.config[:'metric.app.state.exception.tracable'] == 'true' || D13n.config[:'metric.app.state.exception.tracable'] == true
+    end
+
+    def self.service_for(uri)
+      port = (uri.port.to_i == 80 ? "" : ":#{uri.port}")
+      url = "#{uri.scheme}://#{uri.host}#{port}"
+      expected_service = D13n.config.alias_key_for(url)
+      return nil if expected_service.nil?
+      expected_service.to_s.downcase
+    end
+
+    def self.endpoint_for(uri)
+      path = uri.path
+      expected_path = D13n.config.alias_key_for(path)
+      return nil if expected_path.nil?
+      expected_path.to_s.downcase
+    end
+  end
+end

data/lib/d13n/metric/http_clients/http_helper.rb

@@ -0,0 +1,15 @@
+module D13n::Metric::HTTPClients
+  module HTTPHelper
+    def service
+      Helper.service_for(uri)
+    end
+
+    def endpoint
+      Helper.endpoint_for(uri)
+    end
+
+    def service_endpoint
+      [service, endpoint].join('.')
+    end
+  end
+end

data/lib/d13n/metric/http_clients/net_http_wrappers.rb

@@ -0,0 +1,54 @@
+require 'd13n/metric/http_clients/http_helper'
+module D13n::Metric::HTTPClients
+  class NetHTTPClientRequest
+    def initialize(connection, request)
+      @connection = connection
+      @request = request
+    end
+
+    def type
+      'Net::HTTP'
+    end
+
+    def host
+      if hostname = self['host']
+        hostname.split(':').first
+      else
+        @connection.address
+      end
+    end
+
+    def [](key)
+      @request[key]
+    end
+
+    def []=(key, value)
+      @request[key] = value
+    end
+
+    def uri
+      case @request.path
+      when /^https?:\/\//
+        URI(@request.path)
+      else
+        scheme = @connection.use_ssl? ? 'https' : 'http'
+        URI("#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}")
+      end
+    end
+  end
+
+  class NetHTTPClientResponse
+    def initialize(connection, response)
+      @response = response
+    end
+
+    def uri
+      return @response.uri unless @response.uri.nil?
+      nil
+    end
+
+    def status_code
+      @response.code
+    end
+  end
+end

data/lib/d13n/metric/http_clients.rb

@@ -0,0 +1,4 @@
+module D13n::Metric::HTTPClients
+end
+require 'd13n/metric/http_clients/net_http_wrappers'
+

data/lib/d13n/metric/instrumentation/app_exception.rb

@@ -0,0 +1,70 @@
+module D13n::Metric::Instrumentation
+  module AppException
+    def self.included(descendance)
+      descendance.include(InstanceMethods)
+      descendance.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def metric_error_inherated?
+        !!(self < D13n::Metric::MetricError)
+      end
+
+      def exception_with_d13n_instrumentation(*args)
+        return exception_without_d13n_instrumentation(*args) unless metric_error_inherated?
+
+        manager = D13n::Metric::Manager.instance
+        metric = manager.metric(:app_state)
+        
+        if metric.nil?
+          D13n.logger.info "Null intrumentation metric class and ignore collection"
+          return exception_without_d13n_instrumentation(*args)
+        end
+
+        metric.instance(manager, {type: 'exception', at: 'runtime', src: 'app'}).process do
+          exception_without_d13n_instrumentation(*args)
+        end
+      end
+    end
+
+    module InstanceMethods
+      def exception_with_d13n_instrumentation(*args)
+        self.class.exception_with_d13n_instrumentation(*args)
+      end
+    end
+
+    module_function
+    def enable?
+      D13n.config[:'metric.app.state.exception.enable'] == 'true' || D13n.config[:'metric.app.state.exception.enable'] == true
+    end
+  end
+end
+
+D13n::Metric::Instrumentation::Conductor.direct do
+  named :app_exception
+
+  depend_on do
+    D13n::Metric::Instrumentation::AppException.enable?
+  end
+
+  depend_on do
+    defined?(D13n) && defined?(D13n::Error)
+  end
+
+  performances do
+    D13n.logger.info 'Installing Application Exeception instrumentation'
+  end
+
+  performances do
+    class D13n::Error
+      include D13n::Metric::AppException
+      class << self
+        alias exception_without_d13n_instrumentation exception
+        alias exception exception_with_d13n_instrumentation
+      end
+
+      alias exception_without_d13n_instrumentation exception
+      alias exception exception_with_d13n_instrumentation
+    end
+  end
+end

data/lib/d13n/metric/instrumentation/controller_instrumentation.rb

@@ -0,0 +1,91 @@
+require 'd13n/metric/stream'
+require 'd13n/metric/stream_state'
+module D13n::Metric::Instrumentation
+  module ControllerInstrumentation
+    def perform_action_with_d13n_stream(*args, &block)
+      return yield unless ::D13n::Metric::Helper.http_in_tracable?
+      state = D13n::Metric::StreamState.st_get
+      state.request = metric_request(args)
+
+      trace_options = args.last.is_a?(Hash) ? args.last : {}
+      category = trace_options[:category] || :action
+      stream_options = create_stream_options(trace_options, category, state)
+      begin
+        stream = D13n::Metric::Stream.start(state, category, stream_options)
+        
+        begin
+          yield
+        rescue => e
+          D13n::Metric::Manager.notice_error(e)
+          raise
+        end
+      ensure
+        D13n::Metric::Stream.stop(state)
+      end
+    end
+
+    protected
+
+    def create_stream_options(trace_options, category, state)
+      stream_options = {}
+      stream_options[:request] = trace_options[:request]
+      stream_options[:request] ||= request if respond_to?(:request) rescue nil
+      stream_options[:filtered_params] = trace_options[:params]
+      stream_options[:stream_name] = StreamNamer.name_for(nil, self, category, stream_options)
+      stream_options
+    end
+
+    def metric_request(args)
+      opts = args.first
+      if opts.respond_to?(:keys) && opts.respond_to?(:[]) && opts[:request]
+        opts[:request]
+      else self.respond_to?(:request)
+        self.request rescue nil
+      end
+    end
+
+    class StreamNamer
+      def self.name_for(stream, trace_obj, category, options={})
+        "#{prefix_for_category(stream, category)}.#{namespace(trace_obj, options)}"
+      end
+
+      def self.prefix_for_category(stream, category = nil)
+        category ||= (stream && stream.category)
+        case category
+        when :sinatra  then ::D13n::Metric::Stream::SINATRA_PREFIX
+        when :middleware then ::D13n::Metric::Stream::MIDDLEWARE_PREFIX
+        else "#{category.to_s}"
+        end
+      end
+
+      def self.namespace(traced_obj, options={})
+        return options[:namespace] if options[:namespace]
+
+        kls_name = kls_name(traced_obj, options)
+        if options[:name]
+          if kls_name
+            "#{kls_name}.#{options[:name]}"
+          else
+            options[:name]
+          end
+        elsif traced_obj.respond_to?(:d13n_metric_namespace)
+          traced_obj.d13n_metric_namespace
+        else
+          kls_name
+        end
+      end
+
+      def self.kls_name(trace_obj, options={})
+        return options[:class_name] if options[:class_name]
+
+        if (trace_obj.is_a?(Class) || trace_obj.is_a?(Module))
+          return nil if trace_obj.name.nil?
+          trace_obj.name.underscore
+        else
+          return nil if trace_obj.class.name.nil?
+          trace_obj.class.name.underscore
+        end
+      end
+    end
+  end
+end

data/lib/d13n/metric/instrumentation/em-websocket.rb

@@ -0,0 +1,71 @@
+require 'd13n/metric/instrumentation/websocket_instrumentation'
+D13n::Metric::Instrumentation::Conductor.direct do
+  named :'em-websocket'
+
+  depend_on do
+    defined?(::EventMachine) && defined?(::EventMachine::WebSocket) &&
+    defined?(::EventMachine::WebSocket::Connection) && 
+    ::EventMachine::WebSocket::Connection.instance_methods.include?(:onmessage) &&
+    ::EventMachine::WebSocket::Connection.instance_methods.include?(:onclose) &&
+    ::EventMachine::WebSocket::Connection.instance_methods.include?(:onopen)
+  end
+
+  performances do
+    D13n.logger.info 'Installing em-websocket instrumentation'
+  end
+
+  performances do
+    ::EventMachine::WebSocket::Connection.class_eval do
+      include D13n::Metric::Instrumentation::EmWebSocket
+      alias trigger_on_message_without_d13n_instrumentation trigger_on_message
+      alias trigger_on_open_without_d13n_instrumentation trigger_on_open
+      alias trigger_on_close_without_d13n_instrumentation trigger_on_close
+      alias send_without_d13n_instrumentation send
+      
+      alias trigger_on_message trigger_on_message_with_d13n_instrumentation
+      alias trigger_on_open trigger_on_open_with_d13n_instrumentation
+      alias trigger_on_close trigger_on_close_with_d13n_instrumentation
+      alias send send_with_d13n_instrumentation
+    end
+  end
+end
+
+module D13n::Metric::Instrumentation
+  module EmWebSocket
+    include D13n::Metric::Instrumentation::WebSocketInstrumentation
+
+    def self.included(descendance)
+      descendance.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+    end
+
+    def trigger_on_message_with_d13n_instrumentation(*args, &block)
+      options = {:category => :websocket, :name => :websocket_onmessage}
+      request[:request_content_length] = args[0].size if args.is_a?(Array) 
+      
+      perform_websocket_with_d13n_stream(options) do
+        trigger_on_message_without_d13n_instrumentation(*args, &block)
+      end
+    end
+
+    def send_with_d13n_instrumentation(*args, &block)
+      response_length = args[0].size if args.is_a?(Array) 
+      request[:response_content_length] = response_length || 0 if request.is_a?(Hash)
+      send_without_d13n_instrumentation(*args, &block)
+    end
+
+    def trigger_on_open_with_d13n_instrumentation(*args, &block)
+      trigger_on_open_without_d13n_instrumentation(*args, &block)
+    end
+
+    def trigger_on_close_with_d13n_instrumentation(*args, &block)
+      trigger_on_close_without_d13n_instrumentation(*args, &block)
+    end
+  end
+end
+
+
+