vx-instrumentation 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3e2d666dc400fcb14d81f99233e4bf4e544aa594
+  data.tar.gz: ec357619cff76c059cd349c862db172ae4f9ebe5
+SHA512:
+  metadata.gz: 53d7910af3fb3949d6c9df4ebd96b529fe89ed9ee0ee82a62138ff9159875b4d3f5f94579ebf05a79c8024333a4ed247c818b5828bff16d669e4d4fe699e6490
+  data.tar.gz: 9b447bed92a4a082d2372d856ecc84908fd0b0a16af577751441939e48ccd1ff42cfc43b39ca4b6c56df523d6cd5dc21ced96e3bd19f1c610029af5610286c0e

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+-fd
+--order=rand

data/.travis.yml

@@ -0,0 +1 @@
+script: "rspec spec/"

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vx-instrumentation.gemspec
+gemspec
+
+group :development do
+  gem 'rspec'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dmitry Galinsky
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Vx::Instrumentation
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'vx-instrumentation'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vx-instrumentation
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/vx-instrumentation/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/vx/instrumentation/action_dispatch.rb

@@ -0,0 +1,18 @@
+module Vx
+  module Instrumentation
+    class ActionDispatch < Subscriber
+
+      event(/\.action_dispatch$/)
+
+      def process
+        req     = payload.delete(:request)
+        self.payload = {
+          path:   req.fullpath,
+          ip:     req.ip,
+          method: req.method,
+        }
+      end
+
+    end
+  end
+end

data/lib/vx/instrumentation/active_record.rb

@@ -0,0 +1,33 @@
+module Vx
+  module Instrumentation
+    class ActiveRecord < Subscriber
+
+      event(/\.active_record$/)
+
+      def process
+        self.payload = {
+          sql:      payload[:sql].compact,
+          binds:    render_binds,
+          name:     payload[:name],
+          duration: payload[:duration]
+        }
+      end
+
+      private
+
+        def render_binds
+          (payload[:binds] || []).map do |column, value|
+            if column
+              if column.binary?
+                value = "<#{value.bytesize} bytes of binary data>"
+              end
+              [column.name, value]
+            else
+              [nil, value]
+            end
+          end.inspect
+        end
+
+    end
+  end
+end

data/lib/vx/instrumentation/amqp_consumer.rb

@@ -0,0 +1,9 @@
+module Vx
+  module Instrumentation
+    class AmqpConsumer < Subscriber
+
+      event(/\.consumer\.amqp$/)
+
+    end
+  end
+end

data/lib/vx/instrumentation/faraday.rb

@@ -0,0 +1,31 @@
+module Vx
+  module Instrumentation
+    class Faraday < Subscriber
+
+      event 'request.faraday'
+
+      def process
+        self.name    = 'request.http'
+        self.payload = {
+          method:           payload[:method],
+          url:              payload[:url].to_s,
+          status:           payload[:status],
+          response_headers: render_http_header(payload[:response_headers]),
+          request_headers:  render_http_header(payload[:request_headers])
+        }
+      end
+
+      private
+
+        def render_http_header(headers)
+          headers.map do |key,value|
+            if %{ PRIVATE-TOKEN Authorization }.include?(key)
+              value = value.gsub(/./, "*")
+            end
+            "#{key}: #{value}"
+          end.join("\n")
+        end
+
+    end
+  end
+end

data/lib/vx/instrumentation/logger.rb

@@ -0,0 +1,95 @@
+require 'json'
+require 'logger'
+
+module Vx
+
+  module Instrumentation
+
+    class Logger
+
+      def initialize(device)
+        @device = device
+      end
+
+      def method_missing(sym, *args, &block)
+        if @device.respond_to?(sym)
+          begin
+            @device.send(sym, *args, &block)
+          rescue Exception => e
+            $stderr.puts "#{e.class.to_s} in #{e.message.inspect} [#{sym.inspect} #{args.inspect}]"
+            $stderr.puts e.backtrace.map{|b| "    #{b}" }.join("\n")
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to?(sym)
+        @device.respond_to?(sym)
+      end
+
+      class << self
+        attr_accessor :logger
+
+        def setup(target)
+          log = ::Logger.new(target)
+          log.formatter = Formatter
+          $stdout.puts " --> #{self.to_s} to #{target}"
+          @logger = new(log)
+        end
+      end
+
+      class Formatter
+
+        def self.safe_value(value, options = {})
+          case value.class.to_s
+          when "String", "Fixnum", "Float"
+            value
+          when "Symbol", "BigDecimal"
+            value.to_s
+          when "Array"
+            value = value.map(&:to_s)
+            options[:join_arrays] ? value.join("\n") : value
+          else
+            value.inspect
+          end
+        end
+
+        def self.make_safe_hash(msg, options = {})
+          msg.inject({}) do |acc, pair|
+            msg_key, msg_value = pair
+
+            if msg_key == "@fields"
+              acc[msg_key] = make_safe_hash(msg_value, join_arrays: true)
+            else
+              acc[msg_key] = safe_value(msg_value, options)
+            end
+            acc
+          end
+        end
+
+        def self.call(severity, _, _, msg)
+          values = Vx::Instrumentation.default.dup
+
+          case
+          when msg.is_a?(Hash)
+            values.merge! msg
+          when msg.respond_to?(:to_h)
+            values.merge! msg.to_h
+          else
+            values.merge!(message: msg)
+          end
+
+          values.merge!(severity: severity.to_s.downcase)
+
+          values = make_safe_hash(values)
+
+          ::JSON.dump(values) + "\n"
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/vx/instrumentation/rails.rb

@@ -0,0 +1,9 @@
+module Vx
+  module Instrumentation
+    class Rails < Subscriber
+
+      event(/\.(action_controller|action_view|action_mailer|active_support|railties)$/)
+
+    end
+  end
+end

data/lib/vx/instrumentation/subscriber.rb

@@ -0,0 +1,33 @@
+require 'logger'
+require 'active_support/notifications'
+
+module Vx
+  module Instrumentation
+    Subscriber = Struct.new(:name, :payload, :tags) do
+
+      def process ; end
+
+      class << self
+
+        def install
+          ev = event || /.*/
+          $stdout.puts " --> add instrumentation #{self.to_s} to #{ev.inspect}"
+          ActiveSupport::Notifications.subscribe(ev) do |name, started, finished, uid, payload|
+            if name[0] != '!'
+              tags = name.split(".")
+              inst = new(name, payload, tags).tap(&:process)
+              Instrumentation.delivery(inst.name, inst.payload, inst.tags.uniq, started, finished)
+            end
+          end
+        end
+
+        def event(name = nil)
+          @event = name if  name
+          @event
+        end
+
+      end
+
+    end
+  end
+end

data/lib/vx/instrumentation/version.rb

@@ -0,0 +1,5 @@
+module Vx
+  module Instrumentation
+    VERSION = "0.0.1"
+  end
+end

data/lib/vx/instrumentation.rb

@@ -0,0 +1,79 @@
+require 'thread'
+
+require File.expand_path("../instrumentation/version",           __FILE__)
+require File.expand_path("../instrumentation/logger",            __FILE__)
+require File.expand_path("../instrumentation/subscriber",        __FILE__)
+
+require File.expand_path("../instrumentation/faraday",           __FILE__)
+require File.expand_path("../instrumentation/active_record",     __FILE__)
+require File.expand_path("../instrumentation/action_dispatch",   __FILE__)
+require File.expand_path("../instrumentation/rails",             __FILE__)
+require File.expand_path("../instrumentation/amqp_consumer",     __FILE__)
+
+module Vx
+  module Instrumentation
+
+    DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.%N%z'
+    THREAD_KEY  = 'vx_instrumentation_keys'
+
+    extend self
+
+    def install(target, log_level = 0)
+      Instrumentation::Logger.setup target
+      Instrumentation::Logger.logger.level = log_level
+      ObjectSpace.each_object(Class) do |c|
+        next unless c.superclass == Instrumentation::Subscriber
+        c.install
+      end
+    end
+
+    def with(new_keys)
+      old_keys = Thread.current[THREAD_KEY]
+      begin
+        Thread.current[THREAD_KEY] = (old_keys || {}).merge(new_keys)
+        yield if block_given?
+      ensure
+        Thread.current[THREAD_KEY] = old_keys
+      end
+    end
+
+    def default
+      Thread.current[THREAD_KEY] || {}
+    end
+
+    def handle_exception(event, ex, env = {})
+      tags = event.split(".")
+      tags << "exception"
+      tags.uniq!
+
+      payload = {
+        "@event"      => event,
+        "@process_id" => Process.pid,
+        "@thread_id"  => Thread.current.object_id,
+        "@timestamp"  => Time.now.strftime(DATE_FORMAT),
+        "@tags"       => tags,
+        "@fields"     => env,
+        exception: ex.class.to_s,
+        message:   ex.message.to_s,
+        backtrace: (ex.backtrace || []).map(&:to_s).join("\n"),
+      }
+      puts payload.inspect
+      Vx::Instrumentation::Logger.logger.error(payload)
+    end
+
+    def delivery(name, payload, tags, started, finished)
+      Vx::Instrumentation::Logger.logger.log(
+        ::Logger::INFO,
+        "@event"      => name,
+        "@process_id" => Process.pid,
+        "@thread_id"  => Thread.current.object_id,
+        "@timestamp"  => started.strftime(DATE_FORMAT),
+        "@duration"   => (finished - started).to_f,
+        "@fields"     => payload,
+        "@tags"       => tags
+      )
+    end
+
+  end
+
+end

data/spec/lib/instrumentation_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Vx::Instrumentation do
+  let(:out)  { StringIO.new }
+  let(:inst) { described_class }
+  let(:result) {
+    out.rewind
+    JSON.parse out.read
+  }
+
+  it "should successfully install" do
+    expect(inst.install out).to be
+  end
+
+  it "should work with default values" do
+    inst.with(x: "y") do
+      inst.with(a: "b") do
+        expect(inst.default).to eq(
+          x: "y",
+          a: "b"
+        )
+      end
+      expect(inst.default).to eq(x: "y")
+    end
+    expect(inst.default).to eq({})
+  end
+
+  it "should handle exception" do
+    inst::Logger.setup out
+    ex = Exception.new("message")
+    inst.handle_exception('event.name', ex, {key: "value"})
+    expect(result["@event"]).to eq 'event.name'
+    expect(result["@tags"]).to eq ["event", "name", "exception"]
+    expect(result["@fields"]).to eq("key" => "value")
+    expect(result["exception"]).to eq 'Exception'
+    expect(result["message"]).to eq 'message'
+  end
+end

data/spec/lib/logger_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Vx::Instrumentation::Logger do
+  let(:out)    { StringIO.new }
+  let(:logger) { described_class.setup out }
+  let(:result) {
+    out.rewind
+    JSON.parse(out.read)
+  }
+
+  it "should write string mesage" do
+    logger.info "I am string"
+    expect(result).to eq(
+      "message"  => "I am string",
+      "severity" => "info"
+    )
+  end
+
+  it "should write a simple hash" do
+    logger.info(key: "value")
+    expect(result).to eq(
+      'key'      => 'value',
+      "severity" => "info"
+    )
+  end
+
+  it "should write a nested hash" do
+    logger.info(
+      root: {
+        child: {
+          subchild: "value"
+        }
+      }
+    )
+    expect(result).to eq(
+      "root"     => "{:child=>{:subchild=>\"value\"}}",
+      "severity" => "info"
+    )
+  end
+
+  it "should write nested hash with @fields" do
+    logger.info(
+      "@fields" => {
+        child: {
+          subchild: "value"
+        }
+      }
+    )
+    expect(result).to eq(
+      "@fields" => {
+        "child"=>"{:subchild=>\"value\"}"
+      },
+      "severity" => "info"
+    )
+  end
+
+  it "should write nested hash with arrays" do
+    logger.info(
+      a: %w{ 1 2 3 },
+      "@fields" => {
+        c: %w{ 4 5 6 }
+      }
+    )
+    expect(result).to eq(
+      "a" => ["1", "2", "3"],
+      "@fields" => {
+        "c" => "4\n5\n6"
+      },
+      "severity" => "info"
+    )
+  end
+
+  it "should woth with default values" do
+    Vx::Instrumentation.with(foo: "bar") do
+      logger.info(key: "value")
+    end
+    expect(result).to eq(
+      "foo" => "bar",
+      "key" => "value",
+      "severity" => "info"
+    )
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require File.expand_path("../../lib/vx/instrumentation", __FILE__)
+require 'rspec/autorun'
+
+RSpec.configure do |config|
+end

data/vx-instrumentation.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vx/instrumentation/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vx-instrumentation"
+  spec.version       = Vx::Instrumentation::VERSION
+  spec.authors       = ["Dmitry Galinsky"]
+  spec.email         = ["dima.exe@gmail.com"]
+  spec.summary       = %q{ summary }
+  spec.description   = %q{ description }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activesupport', '~> 4.0'
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: vx-instrumentation
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dmitry Galinsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ' description '
+email:
+- dima.exe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vx/instrumentation.rb
+- lib/vx/instrumentation/action_dispatch.rb
+- lib/vx/instrumentation/active_record.rb
+- lib/vx/instrumentation/amqp_consumer.rb
+- lib/vx/instrumentation/faraday.rb
+- lib/vx/instrumentation/logger.rb
+- lib/vx/instrumentation/rails.rb
+- lib/vx/instrumentation/subscriber.rb
+- lib/vx/instrumentation/version.rb
+- spec/lib/instrumentation_spec.rb
+- spec/lib/logger_spec.rb
+- spec/spec_helper.rb
+- vx-instrumentation.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: summary
+test_files:
+- spec/lib/instrumentation_spec.rb
+- spec/lib/logger_spec.rb
+- spec/spec_helper.rb
+has_rdoc: