lens 0.0.6 → 0.0.7

data/lib/lens/railtie.rb

@@ -1,29 +1,19 @@
-require 'rails'
-
 module Lens
   class Railtie < Rails::Railtie
-    ActiveSupport::Notifications.subscribe('start_processing.action_controller') do |name, started, finished, id, data|
-      Trace.create(id)
-    end
-
-    ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
-      next unless Trace.current
-      event = ActiveSupport::Notifications::Event.new(*args)
-      Trace.current.add(event) if event.name != 'SCHEMA'
-    end
+    ActiveSupport::Notifications.subscribe(/.*/) do |name, start, finish, id, payload|
+      event = Event.new(
+        name: name,
+        started: start,
+        finished: finish,
+        transaction_id: id,
+        payload: payload
+      )
 
-    ActiveSupport::Notifications.subscribe(/^render_(template|action|collection)\.action_view/) do |*args|
-      next unless Trace.current
-      event = ActiveSupport::Notifications::Event.new(*args)
-      Trace.current.add(event)
+      Trace.process(event)
     end
 
-    ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
-      next unless Trace.current
-      event = ActiveSupport::Notifications::Event.new(*args)
-      if event.payload[:controller] && event.payload[:action]
-        Trace.current.complete(event)
-      end
+    config.after_initialize do
+      Lens.start
     end
   end
 end

data/lib/lens/sender.rb

@@ -3,66 +3,47 @@ require 'json'
 
 module Lens
   class Sender
-    NOTICES_URI = 'api/v1/data/rec'
-    HTTP_ERRORS = [Timeout::Error,
-                   Errno::EINVAL,
-                   Errno::ECONNRESET,
-                   EOFError,
-                   Net::HTTPBadResponse,
-                   Net::HTTPHeaderSyntaxError,
-                   Net::ProtocolError,
-                   Errno::ECONNREFUSED].freeze
-
-    def initialize(options = {})
-      [ :app_key,
-        :protocol,
-        :host,
-        :port
-      ].each do |option|
-        instance_variable_set("@#{option}", options.send(option))
-      end
+    NOTICES_URI = 'api/v1/events'.freeze
+    HEADERS = {
+      'Content-type' => 'application/json',
+      'Content-Encoding' => 'deflate',
+      'Accept' => 'text/json, application/json',
+      'User-Agent' => "LENS-Ruby client #{VERSION}; #{RUBY_VERSION}; #{RUBY_PLATFORM}"
+    }.freeze
+
+    attr_reader :app_key, :protocol, :host, :port, :compressor
+
+    def initialize(options = nil)
+      raise ArgumentError unless options.is_a? Configuration
+
+      @app_key = options.app_key
+      @protocol = options.protocol
+      @host = options.host
+      @port = options.port
+      @compressor = options.compressor
     end
 
     def send_to_lens(data)
-      response = send_request(url.path, data)
-    end
-
-    attr_reader :app_key,
-      :protocol,
-      :host,
-      :port
-
-  private
-
-    def http_connection
-      setup_http_connection
+      send_request(url.path, compressor.compress(data), compressor.headers)
     end
 
-    def setup_http_connection
-      Net::HTTP.new(url.host, url.port)
-    rescue => e
-      log(:error, "[Lens::Sender#setup_http_connection] Failure initializing the HTTP connection.\nError: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-      raise e
-    end
+    private
 
-    def send_request(path, data, headers = {})
-      http_connection.post(path, data, http_headers(headers))
-    rescue *HTTP_ERRORS => e
-      raise e
-      nil
+    def send_request(path, data, additional_headers = {})
+      headers = http_headers.merge additional_headers
+      http_connection.post(path, data, headers)
     end
 
-    def http_headers(headers=nil)
-      {}.tap do |hash|
-        hash.merge!(HEADERS)
-        hash.merge!({'X-Auth-Token' => app_key})
-        hash.merge!({'Content-Type' =>'application/json'})
-        hash.merge!(headers) if headers
-      end
+    def http_headers
+      HEADERS.merge('X-Auth-Token' => app_key)
     end
 
     def url
       URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
     end
+
+    def http_connection
+      Net::HTTP.new(url.host, url.port)
+    end
   end
 end

data/lib/lens/trace.rb

@@ -1,40 +1,70 @@
-require 'rails'
-
 module Lens
   class Trace
     def initialize(id)
       @id = id
       @data = []
+
+      @gc_statistics = Lens::GC.new
+      @gc_statistics.enable
+
+      @allocations_data = Lens::AllocationsData.new
+      @allocations_data.enable
     end
 
     def add(event)
-      @data.push event.payload.merge(duration: event.duration)
+      @data.push event.payload.merge(
+        etype: event.name,
+        eduration: event.duration,
+        estart: event.time.to_f,
+        efinish: event.end.to_f
+      )
     end
 
     def complete(event)
-      formatted_data = Lens::EventFormatter.new(event, @data).json_formatted
-      log(formatted_data)
+      formatter = Lens::EventFormatter.new(
+        event,
+        @data,
+        @gc_statistics.total_time,
+        @allocations_data
+      )
+      formatted_data = formatter.json_formatted
       send(formatted_data)
       Thread.current[:__lens_trace] = nil
     end
 
-  private
+    private
 
     def send(data)
-      log(data)
-      Lens.sender.send_to_lens(data)
+      Worker.instance.push(data)
     end
+  end
 
-    def log(data)
-      Rails.logger.info "all [LENS] >>> #{data}" if verbose?
+  class << Trace
+    def process(event)
+      create(event.transaction_id) if first_event?(event)
+
+      if Trace.present?
+        current.add(event)
+        current.complete(event) if last_event?(event)
+      end
     end
 
-    def verbose?
-      true
+    def present?
+      current.present?
+    end
+
+    private
+
+    def first_event?(event)
+      event.name == 'start_processing.action_controller'
+    end
+
+    def last_event?(event)
+      event.name == 'process_action.action_controller' &&
+        event.payload[:controller] &&
+        event.payload[:action]
     end
-  end
 
-  class << Trace
     def current
       Thread.current[:__lens_trace]
     end

data/lib/lens/version.rb

@@ -1,3 +1,3 @@
 module Lens
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/lib/lens/worker.rb

@@ -0,0 +1,138 @@
+module Lens
+  class Worker
+    # A queue which enforces a maximum size.
+    # NOTE: can be replaced with SizedQueue?
+    class Queue < ::Queue
+      attr_reader :max_size
+
+      def initialize(options = {})
+        raise ArgumentError unless options[:max_size]
+
+        @max_size = options[:max_size]
+        super()
+      end
+
+      def push(obj)
+        super unless size >= max_size
+      end
+    end
+
+    class << self
+      def instance
+        @instance
+      end
+
+      def running?
+        !instance.nil?
+      end
+
+      def start(config)
+        return instance if running?
+        @instance = new(config)
+      end
+
+      def stop(options = {})
+        @instance.public_send(options[:force] ? :shutdown! : :shutdown) if running?
+      ensure
+        @instance = nil
+      end
+    end
+
+    SHUTDOWN = :__lens_worker_shutdown!
+
+    attr_reader :config, :queue, :pid, :mutex, :thread
+
+    def initialize(config)
+      @config = config
+      @queue = Queue.new(max_size: 100)
+      @mutex = Mutex.new
+      @shutdown = false
+      start
+    end
+
+    def push(obj)
+      if start
+        queue.push(obj)
+      end
+    end
+
+    def start
+      mutex.synchronize do
+        return false if @shutdown
+        return true if thread && thread.alive?
+
+        @pid = Process.pid
+        @thread = Thread.new { run }
+      end
+
+      true
+    end
+
+    def run
+      begin
+        loop do
+          case msg = queue.pop
+          when SHUTDOWN
+            break
+          else
+            process(msg)
+          end
+        end
+      end
+    rescue Exception => e
+    end
+
+    def process(msg)
+      handle_response(notify_backend(msg))
+    rescue StandardError => e
+      sleep(1)
+    end
+
+    def notify_backend(payload)
+      Lens.sender.send_to_lens(payload)
+    end
+
+    def handle_response(response)
+      # TODO: send message back to queue if response status != 200
+      log "handle_response #{response.code}"
+    end
+
+    # Shutdown the worker after sending remaining data.
+    # Returns true.
+    def shutdown
+      mutex.synchronize do
+        @shutdown = true
+        @pid = nil
+        queue.push(SHUTDOWN)
+      end
+
+      return true unless thread
+
+      r = true
+      unless Thread.current.eql?(thread)
+        begin
+          r = !!thread.join
+        ensure
+          shutdown! unless r
+        end
+      end
+
+      r
+    end
+
+    # Immediate shutdown
+    def shutdown!
+      mutex.synchronize do
+        @shutdown = true
+        @pid = nil
+      end
+
+      if thread
+        Thread.kill(thread)
+        thread.join # Allow ensure blocks to execute.
+      end
+
+      true
+    end
+  end
+end

data/lib/lens.rb

@@ -1,14 +1,11 @@
-require "lens/core"
-require 'pry'
+# encoding: utf-8
 
-module Lens
-  HEADERS = {
-    'Content-type' => 'application/json',
-    'Content-Encoding' => 'deflate',
-    'Accept'       => 'text/json, application/json',
-    'User-Agent'   => "LENS-Ruby #{VERSION}; #{RUBY_VERSION}; #{RUBY_PLATFORM}"
-  }.freeze
+raise 'WTF!?!?! Where is Rails man? ❨╯°□°❩╯︵┻━┻' unless defined?(Rails)
+
+require 'lens/core'
+require 'lens/railtie'
 
+module Lens
   class << self
     attr_accessor :sender
     attr_writer :configuration
@@ -17,11 +14,21 @@ module Lens
       yield(configuration)
 
       self.sender = Sender.new(configuration)
-      self.sender
+      self
     end
 
     def configuration
       @configuration ||= Configuration.new
     end
+
+    def start
+      raise ConfigurationError, 'application key required' unless configuration.app_key
+
+      Worker.start(configuration)
+    end
+
+    def stop
+      Worker.stop
+    end
   end
 end

data/spec/lens/event_formatter_spec.rb

@@ -1,7 +1,13 @@
 require 'spec_helper'
 
 describe Lens::EventFormatter do
-  let(:event) { double(payload: {}, duration: 2.33) }
+  let(:event) { double(
+    payload: {},
+    duration: 2.33,
+    time: Time.now - 2.seconds,
+    end: Time.now,
+    name: 'dummy.name')
+  }
   let(:records) { [] }
   let(:formatter) { Lens::EventFormatter.new(event, records) }
 

data/spec/lens/lens_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'support/helpers'
+
+describe Lens do
+  describe '.configure' do
+    context 'when user params' do
+      let(:params) do
+        {
+          app_key: 'secret-key',
+          protocol: 'https',
+          host: 'example.com',
+          port: 8080
+        }
+      end
+      before { configure(params) }
+      subject { described_class.configuration }
+
+      it { expect(subject.app_key).to eq params[:app_key] }
+      it { expect(subject.protocol).to eq params[:protocol] }
+      it { expect(subject.host).to eq params[:host] }
+      it { expect(subject.port).to eq params[:port] }
+    end
+
+    context 'when default params' do
+      describe 'compressor' do
+        subject { described_class.configuration.compressor }
+
+        it { is_expected.to respond_to :compress }
+        it { is_expected.to be Lens::Compression::Gzip }
+      end
+
+      describe 'configuration' do
+        subject { described_class.configuration }
+
+        it { expect(subject.app_key).to eq nil }
+        it { expect(subject.protocol).to eq 'http' }
+        it { expect(subject.host).to eq 'lenshq.io' }
+        it { expect(subject.port).to eq 80 }
+      end
+    end
+  end
+
+  describe '.start' do
+    context 'without configuration' do
+      subject { described_class.start }
+
+      it { expect { subject }.to raise_error Lens::ConfigurationError }
+    end
+
+    context 'with configuration' do
+      let(:params) { { app_key: 'some_key' } }
+
+      around(:example) do |example|
+        configure(params)
+        described_class.start
+
+        example.run
+
+        described_class.stop
+      end
+
+      it 'client has been started properly' do
+        expect(Lens::Worker.running?).to be_truthy
+      end
+    end
+  end
+
+  describe '.stop' do
+    context 'not running' do
+      it 'client has been stopped properly' do
+        expect(Lens::Worker.running?).to be_falsey
+        described_class.stop
+        expect(Lens::Worker.running?).to be_falsey
+      end
+    end
+
+    context 'running' do
+      let(:params) { { app_key: 'some_key' } }
+
+      around(:example) do |example|
+        configure(params)
+        described_class.start
+
+        example.run
+
+        described_class.stop
+      end
+
+      it 'client has been stopped properly' do
+        expect(Lens::Worker.running?).to be_truthy
+        described_class.stop
+        expect(Lens::Worker.running?).to be_falsey
+      end
+    end
+  end
+end
+
+def configure(params)
+  described_class.configure do |config|
+    config.app_key = params[:app_key] if params[:app_key].present?
+    config.protocol = params[:protocol] if params[:protocol].present?
+    config.host = params[:host] if params[:host].present?
+    config.port = params[:port] if params[:port].present?
+  end
+end

data/spec/lens/sender_spec.rb

@@ -2,12 +2,11 @@ require 'spec_helper'
 require 'support/helpers'
 
 describe Lens::Sender do
-  before { reset_config }
+  before { Lens.configure { |config| config.app_key = 'app_key_123' } }
   let(:http) { stub_http }
 
   it "makes a single request when sending notices" do
-    http.should_receive(:post).once
+    expect(http).to receive(:post).once
     Lens.sender.send_to_lens('abc123')
   end
-
 end

data/spec/lens/trace_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe Lens::Trace do
+  describe '.process' do
+    let(:first_event) { generate_event('start_processing.action_controller') }
+    let(:last_event) { generate_event('process_action.action_controller') }
+
+    context 'when first message' do
+      before { described_class.process(first_event) }
+
+      it 'creates new thread' do
+        expect(described_class.present?).to be true
+      end
+    end
+
+    context 'when last message' do
+      before do
+        Lens::Worker.start({})
+        allow_any_instance_of(Lens::Worker).to receive :push
+      end
+
+      it 'kills thread' do
+        described_class.process(first_event)
+        expect(described_class.present?).to be true
+
+        described_class.process(last_event)
+        expect(described_class.present?).to be false
+      end
+
+      it 'pushes data to lens server' do
+        expect_any_instance_of(Lens::Worker).to receive :push
+        described_class.process(first_event)
+        described_class.process(last_event)
+      end
+    end
+  end
+end
+
+def generate_event(name = 'event_name')
+  Lens::Event.new(
+    name: name,
+    started: Time.current,
+    finished: Time.current,
+    transaction_id: 1,
+    payload: {
+      controller: 'controller',
+      action: 'action'
+    }
+  )
+end