d13n 0.5.2

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

@@ -0,0 +1,65 @@
+module D13n::Metric::Instrumentation
+  module Exception
+    def self.included(descendance)
+      descendance.include(InstanceMethods)
+      descendance.extend(ClassMethods)
+    end
+    module ClassMethods
+      def d13n_error_inherated?
+        !!(self < D13n::Error)
+      end
+
+      def exception_with_d13n_instrumentation(*arg)
+        return exception_without_d13n_instrumentation(*arg) if d13n_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(*arg)
+        end
+
+        metric.instance(manager, {type: 'exception', at: 'runtime', src:'others'}).process do
+          exception_without_d13n_instrumentation(*arg)
+        end
+        return exception_without_d13n_instrumentation(*arg)
+      end
+    end
+
+    module InstanceMethods
+      def exception_with_d13n_instrumentation(*arg)
+        self.class.exception_with_d13n_instrumentation(*arg)
+      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 :exception
+
+  depend_on do
+    D13n::Metric::Instrumentation::Exception.enable?
+  end
+
+  performances do
+    D13n.logger.info 'Installing Exeception instrumentation'
+  end
+
+  performances do
+    class StandardError
+      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/middleware_tracing.rb

@@ -0,0 +1,82 @@
+module D13n::Metric::Instrumentation
+  module MiddlewareTracing
+    STREAM_STARTED_KEY = 'd13n.stream_started'.freeze unless defined?(STREAM_STARTED_KEY)
+
+    def call(env)
+      first_middleware = stream_started(env)
+
+      state = D13n::Metric::StreamState.st_get
+
+      begin
+        D13n::Metric::Stream.start(state, category, build_stream_options(env, first_middleware))
+        state.notify_rack_call(env) if first_middleware
+        result = (@target == self) ? traced_call(env) : @target.call(env)
+
+        if first_middleware
+          capture_response_attributes(state, result)
+        end
+
+        result
+      rescue Exception => e
+        D13n.logger.error(e)
+        raise e
+      ensure
+        D13n::Metric::Stream.stop(state)
+      end
+    end
+
+    def capture_response_code(state, result)
+      
+      if result.is_a?(Array) && state.current_stream
+        state.current_stream.http_response_code = result[0]
+      end
+    end
+
+    CONTENT_TYPE = 'Content-Type'.freeze unless defined?(CONTENT_TYPE)
+
+    def capture_response_content_type(state, result)
+      if result.is_a?(Array) && state.current_stream
+        _, headers, _ = result
+        state.current_stream.response_content_type = headers[CONTENT_TYPE]
+      end
+    end
+
+    CONTENT_LENGTH = 'Content-Length'.freeze unless defined?(CONTENT_LENGTH)
+
+    def capture_response_content_length(state, result)
+      if result.is_a?(Array) && state.current_stream
+        _, headers, _ = result
+        state.current_stream.response_content_length = headers[CONTENT_LENGTH]
+      end
+    end
+
+    def capture_response_attributes(state, result)
+      capture_response_code(state, result)
+      capture_response_content_type(state, result)
+      capture_response_content_length(state, result)
+    end
+    #
+    #  stream_name, apdex_started_at, request
+    #
+
+    def build_stream_options(env, first_middleware)
+      opts = @stream_options
+      opts = merge_first_middleware_options(opts, env) if first_middleware
+      opts
+    end
+
+    def merge_first_middleware_options(opts, env)
+      opts[:apdex_started_at] = parse_request_timestamp(env)
+      opts[:request] = ::Rack::Request.new(env) if defined?(::Rack)
+      opts
+    end
+
+    def parse_request_timestamp(env)
+      Time.now.to_f
+    end
+
+    def stream_started(env)
+      env[STREAM_STARTED_KEY] = true unless env[STREAM_STARTED_KEY]
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+
+D13n::Metric::Instrumentation::Conductor.direct do
+  named :net_http
+
+  depend_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+
+  performances do
+    D13n.logger.info 'Installing Net instrumentation'
+    require 'd13n/metric/http_clients/net_http_wrappers'
+  end
+
+  performances do
+    class Net::HTTP
+      def request_with_d13n_instrumentation(request, *args, &block)
+        return request_without_d13n_instrumentation(request, *args, &block) unless started?
+        wrapped_request = D13n::Metric::HTTPClients::NetHTTPClientRequest.new(self, request)
+        manager = D13n::Metric::Manager.instance
+        metric = manager.metric(:app_http)
+
+        if metric.nil?
+          D13n.logger.info "Null intrumentation metric class and ignore collection"
+          return request_without_d13n_instrumentation(request, *args, &block) 
+        end
+
+        metric.instance(manager, direction: 'out').process(wrapped_request) do
+          request_without_d13n_instrumentation(request, *args, &block)
+        end
+      end
+
+      alias request_without_d13n_instrumentation request
+      alias request request_with_d13n_instrumentation
+    end
+  end
+end

data/lib/d13n/metric/instrumentation/sinatra/stream_namer.rb

@@ -0,0 +1,35 @@
+module D13n::Metric::Instrumentation::Sinatra
+  module StreamNamer
+    extend self
+
+    SINATRA_ROUTE = 'sinatra.route'
+    UNKNOWN = 'unknown'.freeze
+    def for_route(env, request)
+      env[SINATRA_ROUTE]
+    end
+
+    def initial_stream_name(request)
+      stream_name(UNKNOWN, request)
+    end
+
+    ROOT = '.'.freeze
+
+
+    def stream_name(route_text, request)
+      verb = http_verb(request)
+
+      route_text = route_text.source if route_text.is_a?(Regexp)
+      name = route_text.gsub(%r{^[/^\\A]*(.*?)[/\$\?\\z]*$}, '\1')
+      name = ROOT if name.empty?
+      name = "#{verb}#{name}" unless verb.nil?
+      name
+    rescue => e
+      ::D13n.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Sinatra transaction name")
+      UNKNOWN
+    end
+
+    def http_verb(request)
+      request.request_method if request.respond_to?(:request_method)
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+require 'd13n/metric/instrumentation/controller_instrumentation'
+require 'd13n/metric/instrumentation/sinatra/stream_namer'
+require 'd13n/rack/metric_middleware'
+D13n::Metric::Instrumentation::Conductor.direct do
+  named :sinatra
+
+  depend_on do
+    D13n.config[:'metric.app.http.in.sinatra.enable'] &&
+    defined?(::Sinatra) && defined?(::Sinatra::Base) &&
+    Sinatra::Base.private_method_defined?(:dispatch!) &&
+    Sinatra::Base.private_method_defined?(:process_route) &&
+    Sinatra::Base.private_method_defined?(:route_eval)
+  end
+
+  performances do
+    D13n.logger.info 'Installing Sinatra instrumentation'
+  end
+
+  performances do
+    ::Sinatra::Base.class_eval do
+      include D13n::Metric::Instrumentation::Sinatra
+      alias dispatch_without_d13n_instrumentation dispatch!
+      alias dispatch! dispatch_with_d13n_instrumentation
+
+      alias process_route_without_d13n_instrumentation process_route
+      alias process_route process_route_with_d13n_instrumentation
+
+      alias route_eval_without_d13n_instrumentation route_eval
+      alias route_eval route_eval_with_d13n_instrumentation
+      
+    end
+  end
+
+  performances do
+    if Sinatra::Base.respond_to?(:build)
+      require 'd13n/rack/metric_middleware'
+
+      ::Sinatra::Base.class_eval do
+        class << self
+          alias build_without_d13n_instrumentation build
+          alias build build_with_d13n_instrumentation
+        end
+      end
+    else
+      D13n.logger.info("Skipping auto-injection of middleware for Sinatra - require Sinatra 1.2.1+")
+    end
+  end
+
+  performances do
+    if defined?(::SinatraWebsocket) &&
+       defined?(::Sinatra::Request) &&
+       Sinatra::Request.respond_to?(:websocket)
+      ::Sinatra::Base.class_eval do
+        class << self
+          alias websocket_without_d13n_instrumentation websocket
+          alias websocket websocket_with_d13n_instrumentation
+        end
+      end
+    end
+  end
+end
+
+module D13n::Metric::Instrumentation
+  module Sinatra
+    include D13n::Metric::Instrumentation::ControllerInstrumentation
+    
+    def self.included(descendance)
+      descendance.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def d13n_middlewares
+        middlewares = []
+        if D13n::Rack::MetricMiddleware.enabled?
+          middlewares << D13n::Rack::MetricMiddleware
+        end
+        middlewares
+      end
+
+      def websocket_with_d13n_instrumentation(*args, &block)
+        websocket_without_d13n_instrumentation(*args, &block)
+      end
+
+      def build_with_d13n_instrumentation(*args, &block)
+        if auto_middleware_enable?
+          d13n_middlewares.each do |middleware_kls|
+            try_to_use(self, middleware_kls)
+          end
+        end
+
+        build_without_d13n_instrumentation(*args, &block)
+      end
+
+      private
+
+      def auto_middleware_enable?
+        D13n.config[:'metric.app.http.in.sinatra.auto_middleware.enable']
+      end
+  
+      
+      def try_to_use(app, clazz)
+        if app.middleware.nil?
+          D13n.logger.debug("Failed to use middle for middleware missing in app")
+          return nil
+        end
+        has_middleware = app.middleware.any? { |info| info[0] == clazz }
+        app.use(clazz) unless has_middleware
+      end
+    end
+
+    def process_route_with_d13n_instrumentation(*args, &block)
+      begin
+        env["d13n.last_route"] = args[0]
+      rescue => e
+        D13n.logger.debug("Failed determining last route in Sinatra", e)
+      end
+
+      process_route_without_d13n_instrumentation(*args, &block)
+    end
+
+    def route_eval_with_d13n_instrumentation(*args, &block)
+      begin
+        stream_name = StreamNamer.for_route(env, request)
+        
+        unless stream_name.nil?
+          ::D13n::Metric::Stream.set_default_stream_name("#{self.class.name}.#{stream_name}", :sinatra)
+        end
+      rescue => e
+        D13n.logger.debug("Failed during route_eval to set stream name", e)
+      end
+
+      route_eval_without_d13n_instrumentation(*args, &block)
+    end
+
+    def dispatch_with_d13n_instrumentation
+      request_params = get_request_params
+      name = StreamNamer.initial_stream_name(request)
+      filter_params = get_filter_parames(request_params)
+      perform_action_with_d13n_stream(:category => :sinatra,
+                                      :name => name,
+                                      :params => filter_params) do
+        dispatch_and_notice_errors_with_d13n_instrumentation
+      end
+    end
+
+    def dispatch_and_notice_errors_with_d13n_instrumentation
+      dispatch_without_d13n_instrumentation
+    ensure
+      had_error = env.has_key?('sinatra.error')
+      ::D13n::Metric::Manager.notice_error(env['sinatra.error']) if had_error
+    end
+
+    def get_request_params
+      begin
+        @request.params
+      rescue => e
+        D13n.logger.debug("Failed to get params from Rack request.", e)
+      end
+    end
+
+    def get_filter_parames(request_params)
+      request_params
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'd13n/metric/stream'
+require 'd13n/metric/stream_state'
+module D13n::Metric::Instrumentation
+  module WebSocketInstrumentation
+    def perform_websocket_with_d13n_stream(*args, &block)
+      state = D13n::Metric::StreamState.st_get
+      category = :websocket
+
+      trace_options = args.last.is_a?(Hash) ? args.last : {}
+      stream_options = create_stream_options(trace_options, category, state)
+
+      begin
+        stream = D13n::Metric::Stream.start(state, category, stream_options)
+
+        begin
+          yield
+          update_stream_data(state)
+        rescue => e
+          D13n::Metric::Manager.notice_error(e)
+          raise
+        ensure
+          D13n::Metric::Stream.stop(state)
+        end
+      end
+    end
+
+    protected
+    def create_stream_options(trace_options, categroy, state)
+      stream_options = {}
+      stream_options[:stream_name]
+      stream_options
+    end
+
+    def update_stream_data(state)
+      stream = state.current_stream
+      stream.http_response_code = 200
+      stream.request_content_length = request.delete(:request_content_length)
+      stream.response_content_type = "websocket"
+      stream.response_content_length = request.delete(:response_content_length)
+    end
+  end
+end

data/lib/d13n/metric/instrumentation.rb

@@ -0,0 +1,41 @@
+require 'd13n/metric/conductor'
+module D13n::Metric::Instrumentation
+  def load_instrumentation_files path
+    Dir.glob(path) do |file|
+      begin
+        require file.to_s
+      rescue => e
+        D13n.logger.warn "Error loading instrumentation file '#{file}':", e
+      end
+    end 
+  end
+
+  def add_instrumentation file
+    if @instrumented
+      load_instrumentation_files file
+    else
+      @instrumentation_files << file
+    end
+  end
+
+  def setup_instrumentation
+    _setup_instrumentation
+  end
+
+private
+  def _setup_instrumentation
+    return if @instrumented
+
+    @instrumentation_files = []
+
+    @instrumented = true
+
+    instrumentation_path = File.expand_path(File.join(File.dirname(__FILE__), 'instrumentation'))
+
+    @instrumentation_files << File.join(instrumentation_path, '*.rb')
+
+    @instrumentation_files.each { |path| load_instrumentation_files(path) }
+    Conductor.perform!
+    D13n.logger.info "Finished instrumentation"
+  end
+end

data/lib/d13n/metric/manager.rb

@@ -0,0 +1,106 @@
+require 'statsd-instrument'
+require 'd13n/metric/metrics'
+require 'd13n/metric/instrumentation'
+require 'd13n/metric/stream'
+module D13n::Metric
+  class MetricInitError < MetricError;end
+  class MetricArgError < MetricError; end
+  class MetricNotFoundError < MetricError; end
+  class InstrumentInitError < MetricError; end
+  class Manager
+    include D13n::Metric::Instrumentation
+    def self.start(channel='logger', opts={})
+      @instance ||= new(channel, opts)
+    end
+
+    def self.instance
+      @instance || start
+    end
+
+    def self.notice_error(exception, opts={})
+      Stream.notice_error(exception, opts)
+    end
+
+    extend Forwardable
+
+    def_delegators StatsD, :measure, :increment, :gauge, :set
+
+    CHANNELS = ['udp', 'logger', 'null']
+
+    METRIC_MAPPING = {
+      'app_state' => AppStateMetric,
+      'app_http' => AppHttpMetric,
+      'app_database' => AppDatabaseMetric,
+      'biz_state' => BizStateMetric
+    }
+
+    attr_reader :channel, :backend
+
+    def initialize(channel, opts={})
+      self.channel = channel
+      @opts = opts
+      set_backend
+      setup_instrumentation
+    end
+
+    def set_backend
+      @backend = if @channel == 'udp'
+        setup_udp_backend
+      elsif @channel == 'logger'
+        setup_logger_backend
+      else @channel == 'null'
+        setup_null_backend
+      end
+      D13n.logger.info "Using #{@backend.to_s} as channel in metric"
+      StatsD.backend = @backend
+    end
+
+    def setup_udp_backend
+      @host = @opts.fetch(:host, default_host)
+      @port = @opts.fetch(:port, default_port)
+      @backend_uri = "#{@host}:#{@port}"
+      @protocol = @opts.fetch(:protocol, default_protocol)
+      StatsD::Instrument::Backends::UDPBackend.new(@backend_uri, @protocol) 
+    end
+
+    def setup_logger_backend
+      @logger = @opts.fetch(:logger, D13n.logger)
+      raise InstrumentInitError.new "Missing Logger for logger backend" if @logger.nil?
+      StatsD::Instrument::Backends::LoggerBackend.new(@logger)
+    end
+
+    def setup_null_backend
+      StatsD::Instrument::Backends::NullBackend.new
+    end
+
+    def channel=(c)
+      @channel = c.to_s.downcase
+      raise MetricArgError.new("Invalid Instrument channel: #{c}") unless CHANNELS.include?(@channel)
+    end
+
+    def metric(type)
+      metric_for(type)
+    rescue MetricNotFoundError => e
+      D13n.logger.error "Instrument Metric Type #{type} Not Found in [#{METRIC_MAPPING.keys.join(',')}]"
+      return nil
+    end
+    
+    def metric_for(type)
+      expected_metric = METRIC_MAPPING[type.to_s.downcase]
+      raise MetricNotFoundError.new "#{type} of metric not found!" if expected_metric.nil?
+      expected_metric
+    end
+
+    def default_host
+      D13n.config[:'service.metric.host'] || 'localhost'
+    end
+
+    def default_port
+      D13n.config[:'service.metric.port'] || 8125
+    end
+
+    def default_protocol
+      D13n.config[:'service.metric.protocol'] || :datadog
+    end
+  end
+end

data/lib/d13n/metric/metrics/app_database_metric.rb

@@ -0,0 +1,4 @@
+module D13n::Metric
+  class AppDatabaseMetric < Base
+  end
+end