d13n 0.5.2

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

@@ -0,0 +1,229 @@
+require 'd13n/ext/string'
+module D13n::Metric
+  class HTTPMetricError < MetricError; end
+  class ServiceNotFound < HTTPMetricError; end
+  class EndpointNotFound < HTTPMetricError; end
+  class AppHttpMetric < Base
+    
+    module Namespace
+      def get_service_endpoint(request)
+        service = Helper.service_for(request.uri)
+        endpoint = Helper.endpoint_for(request.uri)
+        raise ServiceNotFound.new "No matched service for #{request.uri.to_s}" if service.nil?
+        raise EndpointNotFound.new "No matched endpoint for #{request.uri.to_s}" if endpoint.nil?
+        [service, endpoint]
+      end
+
+      def service_metric(request,type)
+        service, endpoint = get_service_endpoint(request)
+        items = []
+        items << prefix
+        items << 'service'
+        items << service
+        items << type.to_s
+        items.join('.')
+      end
+
+      def endpoint_metric(request, type)
+        service, endpoint = get_service_endpoint(request)
+        items = []
+        items << prefix
+        items << 'endpoint'
+        items << service
+        items << endpoint
+        items << type.to_s
+        items.join('.')
+      end
+
+      def http_basic_tags(request)
+        service, endpoint = get_service_endpoint(request)
+        tags = []
+        tags << "idc:#{D13n.idc_name}"
+        tags << "env:#{D13n.idc_env}"
+        tags << "app:#{D13n.app_name}"
+        tags << "srv:#{service}"
+        tags << "endpoint:#{endpoint}"
+        tags
+      end
+
+      def http_status_tags(request, response)
+        tags = http_basic_tags(request)
+        tags << "status:#{response.code}"
+        tags
+      end
+
+      def http_error_tags(response)
+        tags = http_basic_tags
+        tags << "error:#{response.class.name.underscore}"
+        tags
+      end
+
+      def endpoint_status_metric(request,response)
+        "#{service_metric(request,:statue)}.#{response.code}"
+      end
+
+      def service_error_metric(request,response)
+        "#{service_metric(request,:error)}.#{response.class.name.underscore}"
+      end
+    end
+
+    module In
+      include Namespace
+      def process(*args, &block)
+        return yield unless 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)
+
+        t0 = Time.now
+        begin
+          node = start(state, t0, request)
+          response = yield
+        ensure
+          finish(state, t0, node, request, response)
+        end
+        return response
+      end
+
+      def start(state, t0, request)
+        'start'
+      end
+
+      def finish(state, t0, node, request, response)
+        'finish'
+      end
+    end
+
+    module Out
+      include Namespace
+
+      def process(request, collectable=true)
+        state =  D13n::Metric::StreamState.st_get
+
+        return yield unless collectable && Helper.http_out_tracable?
+
+        t0 = Time.now
+        begin
+          node = start(state, t0, request)
+          response = yield
+        rescue ServiceNotFound => err
+          D13n.logger.error err.message
+        rescue Exception => err
+          D13n.logger.debug 'Unexpected exception raise while processing HTTP request metric', err
+        ensure
+          finish(state, t0, node, request, response || err)
+        end
+        return response
+      end
+
+      def start(state, t0, request)
+        inject_request_headers(state, request)
+        stack = state.traced_span_stack
+        node = stack.push_frame(state, prefix , t0)
+        return node
+      rescue => e
+        D13n.logger.error 'Uncaught exception while start processing HTTP request metric', e
+        return nil
+      end
+
+      def inject_request_headers(state, request)
+        stream = state.current_stream
+
+        state.is_cross_app_caller = true
+        if stream
+          request[StreamState::D13N_STREAM_HEADER] = state.referring_stream_id || stream.uuid
+        end
+        request[StreamState::D13N_APP_HEADER] = D13n.app_name        
+      end
+
+      def finish(state, t0, node, request, response)
+        unless t0
+          D13n.logger.error("HTTP request process finished metric without start time. This is probably a bug.")
+          return
+        end
+
+        unless request
+          D13n.logger.error("HTTP request process finished metric without request. This is probably a bug.")
+        end
+        
+        t1 = Time.now
+        duration = t1.to_f - t0.to_f
+        
+        begin
+          scoped_metric = get_service_endpoint(request).join('.')
+          node.name = scoped_metric if node
+          if response
+            collect_error_count(request, response) if response.is_a? Exception
+            if response.is_a? Net::HTTPResponse
+              collect_status_count(request, response)
+              collect_request_timing(request, duration)
+            end
+          else
+            collect_request_count(request)
+          end
+        ensure
+          if node
+            stack = state.traced_span_stack
+            stack.pop_frame(state, node, scoped_metric, t1)
+          end
+        end
+      rescue ServiceNotFound, EndpointNotFound => e
+        D13n.logger.debug "service or endpoind not found while collect HTTP metric:", e.message
+      rescue HTTPMetricError => e
+        D13n.logger.debug "while collect HTTP metric", e.message
+      rescue => e
+        D13n.logger.error "Uncaught exception while finishing an HTTP request metric", e
+      end
+
+      def collect_request_count(request, count=1, rate=1.0)
+        @collector.increment(metric_name('count'), count, sample_rate: rate, tags: http_basic_tags(request))
+      end
+
+      def collect_status_count(request, response, count=1, rate=1.0)
+        @collector.increment(metric_name('count'), count, sample_rate: rate, tags: http_status_tags(request, response))
+      end
+
+      def collect_error_count(request, response, count=1, rate=1.0)
+        @collector.increment(metric_name('count'), count, sample_rate: rate, tags: http_error_tags(request, response))
+      end
+
+      def collect_request_timing(request, timing, rate=1.0)
+        @collector.measure(metric_name('timing'), timing, sample_rate: rate, tags: http_basic_tags(request))
+      end
+    end
+
+    def self.instance(collector, opts)
+      direction = opts[:direction]
+      check_direction(direction)
+      @instance = new(collector, opts)
+      @instance.extend PROCESSOR[direction]
+    end
+
+    PROCESSOR = {
+      'in' =>  In,
+      'out' => Out 
+    }
+
+    def initialize(collector, opts)
+      @collector = collector
+      @opts = opts
+      @direction = @opts[:direction]
+    end
+
+    def prefix
+      "app.http.#{@direction[0]}"
+    end
+
+    def metric_name(type)
+      "#{prefix}.#{type}"
+    end
+
+    def self.check_direction(direction)
+      raise InstrumentNameError.new "Wrong request direction #{direction}!" unless PROCESSOR.keys.include?(direction)
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+module D13n::Metric
+  class AppStateMetric < Base
+    module Namespace
+      def gem_metric_tags(gem_info)
+        tags = []
+        tags << "idc:#{Helper.idc_name}"
+        tags << "env:#{Helper.idc_env}"
+        tags << "app:#{Helper.app_name}"
+        tags << "gem:#{gem_info[0]}"
+        tags << "version:#{gem_info[1]}"
+        tags
+      end
+
+      def exception_metric_tags(exception, opts)
+        tags = []
+        tags << "idc:#{Helper.idc_name}"
+        tags << "env:#{Helper.idc_env}"
+        tags << "app:#{Helper.app_name}"
+        tags << "name:#{exception.class.name}"
+        tags << "at:#{opts.fetch(:at, 'runtime')}"
+        tags << "src:#{opts.fetch(:src, 'app')}"
+        tags << "uuid:#{opts.fetch(:uuid, 'unknown')}"
+        tags << "stream_id:#{opts[:referring_stream_id] || opts.fetch(:uuid, 'unknown')}"
+        tags
+      end
+    end
+
+    module GemProcessor
+      include Namespace
+
+      def process
+        load_gem_spec.each do |g| 
+          collect_gem_gauge(g)
+        end
+      end
+
+      def load_gem_spec
+        Gem.loaded_specs.inject({}) {
+          |m, (n,s)| m.merge(n => s.version)
+        }
+      end
+
+      def collect_gem_gauge(named_gem,gauge=1, rate=1.0)
+        @collector.gauge(metric_name('gauge'), gauge, sample_rate:rate, tags: gem_metric_tags(named_gem))
+      end
+    end
+
+    module ExceptionProcessor
+      include Namespace
+
+      def process
+        return yield unless Helper.exception_tracable?
+
+        begin
+          exception = yield
+        ensure
+          finish(exception)
+        end
+        return exception
+      end
+
+      def finish(exception)
+        metric_data = D13n::Metric::StreamState.default_metric_data
+        @opts.merge!(metric_data)
+        collect_exception_count(exception, @opts)
+      end
+
+      def collect_exception_count(exception, opts, count=1, rate=1.0)
+        @collector.increment(metric_name('count'), count, sample_rate: rate, tags: exception_metric_tags(exception,opts))
+      end
+    end
+
+    PROCESSOR = {
+      'gem' => GemProcessor,
+      'exception' => ExceptionProcessor
+    }
+
+    def self.check_type(type)
+      raise InstrumentNameError.new "Wrong request process type #{type}!" unless PROCESSOR.has_key?(type)
+    end
+
+    def self.instance(collector, opts)
+      type = opts[:type]
+      check_type(type)
+      @instance = new(collector, opts)
+      @instance.extend PROCESSOR[type]
+    end
+
+    def initialize(collector, opts)
+      @collector = collector
+      @opts = opts
+      @type = @opts[:type]
+    end
+
+    def metric_name(type)
+      "#{prefix}.#{type}"
+    end
+
+    def prefix
+      "app.state.#{@type}"
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module D13n::Metric
+  class InstrumentNameError < MetricError; end
+  class Base
+    attr_reader :prefix
+
+    def prefix
+      raise NotImplementedError
+    end
+
+    def process(&block)
+      raise NotImplementedError
+    end
+  end
+end

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

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

data/lib/d13n/metric/metrics.rb

@@ -0,0 +1,6 @@
+require 'd13n/metric/helper'
+require 'd13n/metric/metrics/base'
+require 'd13n/metric/metrics/app_database_metric'
+require 'd13n/metric/metrics/app_http_metric'
+require 'd13n/metric/metrics/app_state_metric'
+require 'd13n/metric/metrics/biz_state_metric'

data/lib/d13n/metric/stream/span_tracer_helpers.rb

@@ -0,0 +1,72 @@
+require 'd13n/metric/stream/stream_tracer_helpers'
+module D13n::Metric
+  class Stream
+    module SpanTracerHelpers
+      MAX_ALLOWED_METRIC_DURATION = 1_000_000_000
+      include StreamTracerHelpers::Namer
+
+
+      extend self
+
+      def collect_span_duration_timing(collector, state, name, timing, metric_data, options, rate=1.0)
+        collector.measure(metric_name("timing"), timing, sample_rate: rate, tags: stream_duration_tags(metric_data))
+      end
+
+      def collect_span_exclusive_timing(collector, state, name, timing, metric_data, options, rate=1.0)
+        collector.measure(metric_name("timing"), timing, sample_rate: rate, tags: stream_exclusive_tags(metric_data))
+      end
+
+      def collect_span_request_count(collector, state, name, metric_data, options, count = 1, rate = 1.0)
+        collector.increment(metric_name("count"), count, sample_rate: rate, tags: stream_request_tags(metric_data))
+      end
+
+      def collect_span_metrics(state, first_name, duration, exclusive, metric_data, options)
+        collector = D13n::Metric::Manager.instance
+        collect_span_duration_timing(collector, state, first_name, duration, metric_data, options)
+        collect_span_exclusive_timing(collector, state, first_name, exclusive, metric_data, options)
+        collect_span_request_count(collector, state, first_name, metric_data, options)
+      end
+
+      def trace_header(state, t0)
+        stack = state.traced_span_stack
+        stack.push_frame(state, :span_tracer, t0)
+      end
+
+      def trace_footer(state, t0, first_name, expected_frame, options, t1=Time.now.to_f)
+        if expected_frame
+          stack = state.traced_span_stack
+          frame = stack.pop_frame(state, expected_frame, first_name, t1)
+          duration, exclusive = get_timings(t0, t1, frame)
+          metric_data = {:exclusive => exclusive}
+          get_metric_data(state, t0, t1, metric_data)
+
+          if duration < MAX_ALLOWED_METRIC_DURATION
+            if duration < 0
+              D13n.logger.warn("metric_duration_negative:#{first_name} Metric #{first_name} has negative duration: #{duration} s")
+            end
+
+            if exclusive < 0
+              D13n.logger.warn("metric_exclusive_negative: #{first_name} Metric #{first_name} has negative exclusive time: duration = #{duration} s, child_time = #{frame.children_time}")
+            end
+
+            collect_span_metrics(state, first_name, duration, exclusive, metric_data, options)
+          else
+            D13n.logger.warn("too_huge_metric:#{first_name}, Ignoring metric #{first_name} with unacceptably large duration: #{duration} s")
+          end
+
+        end
+      end
+
+      def get_timings(t0, t1, frame)
+        duration = t1 - t0
+        exclusive = duration - frame.children_time
+        [duration, exclusive]
+      end
+
+      def get_metric_data(state, t0, t1, metric_data)
+        stream = state.current_stream
+        stream.generate_default_metric_data(state, t0, t1, metric_data)
+      end
+    end
+  end
+end

data/lib/d13n/metric/stream/stream_tracer_helpers.rb

@@ -0,0 +1,141 @@
+module D13n::Metric
+  class Stream
+    module StreamTracerHelpers
+      module Namer
+        def prefix
+          "app.http.i"
+        end
+  
+        def metric_name(type)
+          "#{prefix}.#{type}"
+        end
+  
+        def stream_basic_tags(metric_data)
+          tags = []
+          tags << "idc:#{D13n.idc_name}"
+          tags << "env:#{D13n.idc_env}"
+          tags << "app:#{D13n.app_name}"
+          tags << "name:#{metric_data[:name]}"
+          tags << "uuid:#{metric_data[:uuid]}"
+          tags << "stream_id:#{metric_data[:referring_stream_id] || metric_data[:uuid]}"
+          tags << "type:#{metric_data[:referring_stream_id].nil? ? 'stream' : 'span'}"
+          tags
+        end
+  
+        def stream_duration_tags(metric_data)
+          tags = stream_basic_tags(metric_data)
+          tags << "time:duration"
+          tags
+        end
+  
+        def stream_exclusive_tags(metric_data)
+          tags = stream_basic_tags(metric_data)
+          tags << "time:exclusive"
+          tags
+        end
+  
+        def stream_request_tags(metric_data)
+          tags = stream_basic_tags(metric_data)
+          tags
+        end
+
+        def stream_http_response_code_tags(metric_data)
+          tags = stream_basic_tags(metric_data)
+          tags << "response:code"
+          tags << "code:#{metric_data[:http_response_code]}"
+          tags
+        end
+
+        def stream_http_response_content_type_tags(metric_data)
+          tags = stream_basic_tags(metric_data)
+          tags << "response:type"
+          tags << "type:#{metric_data[:http_response_content_type]}"
+          tags
+        end
+
+        def stream_http_request_content_length_tags(metric_data)
+          tags = stream_basic_tags(metric_data)
+          tags << "request:length"
+          tags
+        end
+
+        def stream_http_response_content_length_tags(metric_data)
+          tags = stream_basic_tags(metric_data)
+          tags << "response:length"
+          tags
+        end
+  
+        def stream_error_tags(metric_data, error)
+          tags = stream_basic_tags(metric_data)
+          tags << "error:#{error.is_a?(Class) ? error.name : error.class.name}"
+          tags
+        end
+
+        def stream_apdex_tags(metric_data)
+          tags = stream_basic_tags(metric_data)
+          tags << "apdex_zone:#{metric_data[:apdex_perf_zone]}"
+          tags
+        end
+      end
+
+      include Namer
+      extend self
+
+      def collect_duration_metric(collector, state, timing, metric_data, rate=1.0)
+        collector.measure(metric_name("timing"), timing, sample_rate: rate, tags: stream_duration_tags(metric_data))
+      end
+
+      def collect_exclusive_metric(collector, state, timing, metric_data, rate=1.0)
+        collector.measure(metric_name("timing"), timing, sample_rate: rate, tags: stream_exclusive_tags(metric_data))
+      end
+
+      def collect_apdex_metric(collector, state, metric_data, count=1,rate=1.0)
+        collector.increment(metric_name("count"), count, sample_rate: rate, tags: stream_apdex_tags(metric_data))
+      end
+
+      def collect_repsonse_code_metric(collector, state, metric_data, count=1,  rate=1.0)
+        collector.increment(metric_name("count"), count, sample_rate: rate, tags: stream_http_response_code_tags(metric_data))
+      end
+
+      def collect_response_content_type_metric(collector, state, metric_data, count=1,  rate=1.0)
+        collector.increment(metric_name("count"), count, sample_rate: rate, tags: stream_http_response_content_type_tags(metric_data))
+      end
+
+      def collect_response_content_length_metric(collector, state, gauge, metric_data, rate=1.0)
+        collector.gauge(metric_name("gauge"), gauge.to_i, sample_rate: rate, tags: stream_http_response_content_length_tags(metric_data))
+      end
+
+      def collect_request_content_length_metric(collector, state, gauge, metric_data, rate=1.0)
+        collector.gauge(metric_name("gauge"), gauge.to_i, sample_rate: rate, tags: stream_http_request_content_length_tags(metric_data))
+      end
+
+      def collect_response_metric(collector, state, metric_data)
+        collect_repsonse_code_metric(collector, state, metric_data)
+        collect_response_content_type_metric(collector, state, metric_data)
+        collect_response_content_length_metric(collector, state, metric_data[:http_response_content_length], metric_data)
+        collect_request_content_length_metric(collector, state, metric_data[:http_request_content_length], metric_data) unless metric_data[:http_request_content_length].to_i == 0
+      end
+
+      def collect_error_metric(collector, state, error, metric_data, count=1, rate=1.0 )
+        collector.increment(metric_name('count'), count, sample_rate: rate, tags: stream_error_tags(metric_data, error))
+      end
+
+      def collect_errors_metric(collector, state, metric_data)
+        errors = metric_data[:errors]
+
+        errors.each do |error|
+          collect_error_metric(collector, state, error, metric_data)
+        end
+      end
+
+      def collect_metrics(state, metric_data)
+        collector = D13n::Metric::Manager.instance
+        collect_duration_metric(collector, state, metric_data[:duration], metric_data)
+        collect_exclusive_metric(collector, state, metric_data[:exclusive], metric_data)
+        collect_apdex_metric(collector, state, metric_data)
+        collect_response_metric(collector, state, metric_data)
+        collect_errors_metric(collector, state, metric_data) if metric_data[:error]
+      end
+    end
+  end
+end

data/lib/d13n/metric/stream/traced_span_stack.rb

@@ -0,0 +1,73 @@
+module D13n::Metric
+  class Stream
+    class UnexpectedStackError < D13n::Error;end
+    class StackFrame
+      attr_reader :tag
+      attr_accessor :name, :start_time, :children_time, :end_time
+      def initialize(tag, start_time)
+        @tag = tag
+        @start_time = start_time
+        @children_time = 0
+      end
+    end
+
+    class TracedSpanStack
+      def initialize
+        @stack = []
+      end
+
+      def push_frame(state, tag, time = Time.now.to_f)
+        frame = StackFrame.new(tag, time)
+        @stack.push frame
+        frame
+      end
+
+      def pop_frame(state, expected_frame, name, time, deduct_call_time_from_parent=true)
+        frame = fetch_matching_frame(expected_frame)
+        frame.end_time = time
+        frame.name = name
+
+        note_children_time(frame, time, deduct_call_time_from_parent)
+
+        frame
+      end
+
+      def fetch_matching_frame(expected_frame)
+        while frame = @stack.pop
+          if frame == expected_frame
+            return frame
+          else
+            D13n.logger.info("Unexpected frame in traced method stack: #{frame.inspect} expected to be #{expected_frame.inspect}")
+          end
+        end
+        raise UnexpectedStackError.new "Frame not found in stack: #{expected_frame.inspect}"
+      end
+
+      def note_children_time(frame, time, deduct_call_time_from_parent)
+        if !@stack.empty?
+          if deduct_call_time_from_parent
+            @stack.last.children_time += (time - frame.start_time)
+          else
+            @stack.last.children_time += frame.children_time
+          end
+        end
+      end
+
+      def empty?
+        @stack.empty?
+      end
+
+      def clear
+        @stack.clear
+      end
+
+      def last
+        @stack.last
+      end
+
+      def size
+        @stack.size
+      end
+    end
+  end
+end