app_perf_rpm 0.0.5 → 0.0.6

data/lib/app_perf_rpm/aggregator.rb

@@ -1,77 +0,0 @@
-require 'digest/md5'
-
-module AppPerfRpm
-  class Aggregator
-    def initialize
-    end
-
-    def aggregate(traces)
-      metrics = []
-      traces = arrange_traces(traces)
-      spans = traces_to_spans(traces)
-      spans_by_time(spans).each_pair do |time, spans|
-        group_spans(spans).each_pair do |(type, layer, domain, url, controller, action), grouped_spans|
-          opts = {}
-          opts["type"] = type if type
-          opts["layer"] = layer if layer
-          opts["domain"] = domain if domain
-          opts["url"] = url if url
-          opts["controller"] = controller if controller
-          opts["action"] = action if action
-          metrics << build_metric("trace.web.request.duration", time, grouped_spans, opts)
-        end
-      end
-
-      return metrics
-    end
-
-    private
-
-    def build_metric(metric_name, time, spans, opts)
-      num_spans = spans.uniq(&:trace_id).size
-      durations = spans.inject(0.0) {|s, x| s + x.exclusive_duration }.to_f
-      hits = spans.size
-
-      tags = {
-        "traces" => num_spans,
-        "hits" => hits
-      }.merge(opts)
-
-      ["metric", time.to_f, metric_name, durations, tags]
-    end
-
-    def arrange_traces(traces)
-      traces
-        .group_by(&:trace_id)
-        .map {|span| Span.arrange(span.last.dup) }
-    end
-
-    def traces_to_spans(traces)
-      traces
-        .map {|trace| trace.to_spans}
-        .flatten
-    end
-
-    def spans_by_time(spans)
-      spans.group_by {|span|
-        AppPerfRpm.floor_time(Time.at(span.started_at), dispatch_interval)
-      }
-    end
-
-    def group_spans(spans)
-      spans
-        .group_by {|span| [
-          span.type,
-          span.layer,
-          span.domain,
-          span.url,
-          span.controller,
-          span.action
-        ]}
-    end
-
-    def dispatch_interval
-      30
-    end
-  end
-end

data/lib/app_perf_rpm/dispatcher.rb

@@ -1,85 +0,0 @@
-require 'net/http'
-
-module AppPerfRpm
-  class Dispatcher
-    def initialize
-      @start_time = Time.now
-      @queue = Queue.new
-      @aggregator = Aggregator.new
-    end
-
-    def add_event(event)
-      @queue << event
-    end
-
-    def configuration
-      ::AppPerfRpm.configuration
-    end
-
-    def ready?
-      Time.now > @start_time + configuration.dispatch_interval.to_f &&
-      @queue.size.to_i > 0
-    end
-
-    def reset
-      @queue.clear
-      @start_time = Time.now
-    end
-
-    def dispatch
-      begin
-        spans = drain(@queue)
-        metrics = []#@aggregator.aggregate(spans)
-
-        dispatch_events(spans.map(&:to_a) + metrics)
-      rescue => ex
-        ::AppPerfRpm.logger.error "#{ex.inspect}"
-        ::AppPerfRpm.logger.error "#{ex.backtrace.inspect}"
-      ensure
-        reset
-      end
-    end
-
-    private
-
-    def dispatch_events(data)
-      if data && data.length > 0
-        uri = URI(url)
-
-        sock = Net::HTTP.new(uri.host, uri.port)
-        sock.use_ssl = configuration.ssl
-
-        req = Net::HTTP::Post.new(uri.path, { "Content-Type" => "application/json", "Accept-Encoding" => "gzip", "User-Agent" => "gzip" })
-        req.body = compress_body(data)
-        req.content_type = "application/octet-stream"
-
-        res = sock.start do |http|
-          http.read_timeout = 30
-          http.request(req)
-        end
-        data.clear
-      end
-    end
-
-    def compress_body(data)
-      body = Oj.dump({
-        "name" => configuration.application_name,
-        "host" => AppPerfRpm.host,
-        "data" => data
-      })
-
-      compressed_body = Zlib::Deflate.deflate(body, Zlib::DEFAULT_COMPRESSION)
-      Base64.encode64(compressed_body)
-    end
-
-    def drain(queue)
-      Array.new(queue.size) { queue.pop }
-    end
-
-    def url
-      host = configuration.host
-      license_key = configuration.license_key
-      @url ||= "#{host}/api/listener/2/#{license_key}"
-    end
-  end
-end

data/lib/app_perf_rpm/middleware.rb

@@ -1,30 +0,0 @@
-module AppPerfRpm
-  class Middleware
-    attr_reader :app
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      begin
-        @status, @headers, @response = @app.call(env)
-      rescue Exception => e
-        handle_exception(env, e)
-      end
-      [@status, @headers, @response]
-    end
-
-    def handle_exception(env, exception)
-      ::AppPerfRpm::Tracer.log_event("error",
-        "path" => env["PATH_INFO"],
-        "method" => env["REQUEST_METHOD"],
-        "message" => exception.message,
-        "error_class" => exception.class.to_s,
-        "backtrace" => ::AppPerfRpm::Backtrace.clean(exception.backtrace),
-        "source" => ::AppPerfRpm::Backtrace.source_extract(exception.backtrace)
-      )
-      raise exception
-    end
-  end
-end

data/lib/app_perf_rpm/span.rb

@@ -1,103 +0,0 @@
-module AppPerfRpm
-  class Span
-    attr_accessor :layer,
-                  :controller,
-                  :action,
-                  :url,
-                  :domain,
-                  :type,
-                  :backtrace,
-                  :source,
-                  :trace_id,
-                  :started_at,
-                  :ended_at,
-                  :children,
-                  :options
-
-    def self.arrange(spans)
-      spans.sort! { |a, b| (a.ended_at <=> b.ended_at) }
-
-      null_span = Span.new
-      controller = (spans.find {|s| s.controller } || null_span).controller
-      action = (spans.find {|s| s.action } || null_span).action
-      domain = (spans.find {|s| s.domain } || null_span).domain
-      url = (spans.find {|s| s.url } || null_span).url
-
-      while span = spans.shift
-        span.controller ||= controller
-        span.action ||= action
-        span.domain ||= domain
-        span.url ||= url
-
-        if parent = spans.find { |n| n.parent_of?(span) }
-          parent.children << span
-        elsif spans.empty?
-          root = span
-        end
-      end
-
-      root
-    end
-
-    def initialize
-      self.children = []
-      self.type = "web"
-      self.options = {}
-    end
-
-    def duration
-      @duration ||= (ended_at - started_at) * 1000.0
-    end
-
-    def exclusive_duration
-      @exclusive_duration ||= duration - children.inject(0.0) { |sum, child| sum + child.duration }
-    end
-
-    def parent_of?(span)
-      start = (started_at - span.started_at) * 1000.0
-      start <= 0 && (start + duration >= span.duration)
-    end
-
-    def child_of?(span)
-      span.parent_of?(self)
-    end
-
-    def to_spans
-      span = self.dup
-      span.exclusive_duration
-      span.children = []
-
-      if children.size > 0
-        return [span] + children.map(&:to_spans)
-      else
-        return [span]
-      end
-    end
-
-    def base_options
-      opts = {}
-      opts["domain"] = domain
-      opts["controller"] = controller
-      opts["action"] =  action
-      opts["url"] = url
-      opts["type"] = type
-      #opts["backtrace"] = ::AppPerfRpm::Backtrace.backtrace
-      opts["source"] = ::AppPerfRpm::Backtrace.source_extract
-      opts.delete_if { |k, v| v.nil? }
-    end
-
-    def to_s
-      "#{layer}:#{trace_id}:#{started_at}:#{exclusive_duration}"
-    end
-
-    def to_a
-      [
-        layer,
-        trace_id,
-        started_at,
-        duration,
-        base_options.merge(options)
-      ]
-    end
-  end
-end

data/lib/app_perf_rpm/worker.rb

@@ -1,46 +0,0 @@
-module AppPerfRpm
-  class Worker
-    def initialize
-      AppPerfRpm.logger.info "Starting worker."
-      @dispatcher = Dispatcher.new
-    end
-
-    def save(event)
-      start
-      return if event.nil?
-      @dispatcher.add_event(event)
-    end
-
-    def start
-      return if worker_running?
-      ::AppPerfRpm.mutex.synchronize do
-        return if worker_running?
-        start_dispatcher
-        ::AppPerfRpm.logger.info "Worker is running."
-      end
-    end
-
-    def worker_running?
-      @worker_thread && @worker_thread.alive?
-    end
-
-    def start_dispatcher
-      @worker_thread = Thread.new do
-        ::AppPerfRpm.configuration.reload
-        @dispatcher.reset
-
-        loop do
-          start = Time.now
-          if @dispatcher.ready?
-            @dispatcher.dispatch
-            @dispatcher.reset
-          end
-          sleep_for = (start + 15 - Time.now)
-          sleep_for = 1 if sleep_for < 1
-          sleep sleep_for
-        end
-      end
-      @worker_thread.abort_on_exception = true
-    end
-  end
-end