process_metrics 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60c71413069134039aeacc1348863efe45184b24
+  data.tar.gz: ec20a17b8047721208c0ac6b3135f424b3df31f5
+SHA512:
+  metadata.gz: 638f0704e0ba772963b5f72f36773a46d8661750d232ddbc979afa5facbb34e0f29982da40ab7759971398da4052ca17267ff1c088f85ab688459074340e97e9
+  data.tar.gz: b10606a34d866cca1abaa4d78c94c4e156ce824f4f5735d54ebd2a645a00885f5b68902e00e62e86ed85900d02f2c34821206585d837108d7e93d2d2aa58127a

data/README.md

@@ -0,0 +1,142 @@
+[![Code Climate](https://codeclimate.com/github/lucasuyezu/metric.png)](https://codeclimate.com/github/lucasuyezu/metric)
+
+Process Metrics
+===============
+
+This project aims to collect metrics for processes.
+
+It differs from other metric gems by measuring **processes** instead of code execution.
+
+A process can begin in one point in time and finish in another thread, or even another server.
+
+Features
+========
+
+- Sub-process: Start a process, track each individual step and see the global metric. This is similar to how web browsers show you in the Network view how much time each asset takes to load. See where the holes are.
+- Unobtrusive: Failure in saving a metric will not break your code unless you use `Metric.measure!`, `Metric#find!` and `Metric#finish!`
+- Assyncronous: Persistence is made in parallel, so measurement itself will not affect the results.
+- Multiple data stores: ActiveRecord for now. Leela2 in the near future. Implement your own if you want/need.
+
+Usage
+=====
+
+Manual
+------
+
+### Single process
+
+```ruby
+ProcessMetrics.measure('name') do |metric|
+  do_work
+  metric.data = { key: 'value' }  # optional
+end
+```
+
+### Sub Process in the same block
+```ruby
+ProcessMetrics.measure('name') do |metric|
+  metric.measure('first sub process') do |sub_metric|
+    do_work
+    sub_metric.data = { key: 'value' } # optional
+  end
+
+  do_more_work
+
+  metric.measure('second sub process') do |sub_metric|
+    do_even_more_work
+    sub_metric.data = { key: 'value' } # optional
+  end
+end
+```
+
+### Sub Processes in different places
+```ruby
+# in app/controller/my_controller.rb
+metric = ProcessMetrics.new 'name' # metric objects have an uuid
+save_metric(metric.uuid)
+schedule_worker
+
+# in lib/workers/my_worker.rb
+ProcessMetrics.find(metric_uuid).measure('sub process') do |sub_metric|
+  do_work
+  submetric.data = { key: 'value' }  # optional
+end
+```
+
+Automatic
+---------
+
+### Single process
+```ruby
+class MyModel
+  include ProcessMetrics::Timer
+  measure :perform,
+          name: -> { "metric name" } # Default would be "MyModel#perform"
+
+  def perform
+    do_some_work
+  end
+end
+```
+
+### Sub processes
+```ruby
+class MyWorker
+  include ProcessMetrics::Timer
+  measure :perform,
+          parent_metric_uuid: -> { "2d931510-d99f-494a-8c67-87feb05e1594" }
+
+  belongs_to :my_model
+
+  def perform
+    do_some_work
+  end
+end
+```
+
+Persistence
+===========
+
+Data collected will be serialized into a json and persisted.
+You can put any data you like into the data field and it will be serialized as well.
+
+
+```json
+{
+    "metrics": [{
+        "uuid": "bad85eb9-0713-4da7-8d36-07a8e4b00eab",
+        "name": "virtual_machine_provisioning",
+        "started_at": "2014-03-13T11:34:53-03:00",
+        "finished_at": "2014-03-13T11:35:14-03:00",
+        "data": {
+            "customer_login": "anon",
+            "provisioning_id": 6000123456,
+            "object_type": "virtual_machine",
+            "object_id": "cpro123456"
+        },
+        "links": {
+            "metrics": [
+                "2d931510-d99f-494a-8c67-87feb05e1594",
+                "62936e70-1815-439b-bf89-8492855a7e6b"
+            ]
+        }
+    }]
+}
+```
+
+Configuration
+=============
+
+One time, in a migration
+------------------------
+```ruby
+ProcessMetrics::Persistence::ActiveRecord.setup!
+```
+
+Then, in an initializer
+-----------------------
+
+```ruby
+ProcessMetrics.logger = Rails.logger
+ProcessMetrics.persistence = Metric::Persistence::ActiveRecord # Default is Logger
+```

data/lib/process_metrics/base.rb

@@ -0,0 +1,57 @@
+require 'securerandom'
+
+module ProcessMetrics
+  class Base
+    attr_accessor :data, :uuid
+
+    def initialize(name, parent=nil)
+      @uuid        = SecureRandom.uuid
+      @parent_uuid = parent ? parent.uuid : nil
+      @data        = nil
+      @name        = name
+      @started_at  = Time.now
+      @finished_at = nil
+    end
+
+    def attributes
+      {
+        uuid: @uuid,
+        parent_uuid: @parent_uuid,
+        name: @name,
+        data: @data,
+        started_at: @started_at,
+        finished_at: @finished_at
+      }
+    end
+
+    def serialized_attributes
+      {
+        uuid: @uuid,
+        parent_uuid: @parent_uuid,
+        name: @name,
+        data: @data,
+        started_at: @started_at.strftime("%Y-%m-%d %H:%M:%S.%N"),
+        finished_at: @finished_at.strftime("%Y-%m-%d %H:%M:%S.%N")
+      }
+    end
+
+    def save
+      @finished_at = Time.now
+      ProcessMetrics.config.persistence.save(self)
+    end
+
+    def measure(name, &block)
+      work(name, self, &block)
+    end
+
+    def self.work(name, parent=nil, &block)
+      metric = ProcessMetrics::Base.new name, parent
+      block.call metric
+      metric.save
+    end
+
+    def to_s
+      self.class.name + " " + serialized_attributes.to_s
+    end
+  end
+end

data/lib/process_metrics/config.rb

@@ -0,0 +1,18 @@
+require 'hashie'
+require 'logger'
+require 'process_metrics/persistence'
+
+module ProcessMetrics
+  class Config < Hashie::Mash
+    def initialize
+      self.logger = Logger.new("metric.log")
+      self.persistence = ProcessMetrics::Persistence::Logger
+      self.active_record = Hashie::Mash.new
+      self.active_record.table_name = 'metrics'
+    end
+  end
+
+  def self.config
+    Config.new
+  end
+end

data/lib/process_metrics/persistence/logger.rb

@@ -0,0 +1,9 @@
+module ProcessMetrics
+  module Persistence
+    module Logger
+      def self.save metric
+        ProcessMetrics.logger.info(metric.to_s)
+      end
+    end
+  end
+end

data/lib/process_metrics/persistence.rb

@@ -0,0 +1 @@
+require 'process_metrics/persistence/logger'

data/lib/process_metrics/timer.rb

@@ -0,0 +1,71 @@
+module ClassMethods
+  @@replacing = false
+
+  def measure(*methods_names)
+    options = extract_options(methods_names)
+
+    methods_names.each do |method_name|
+      measure_method_name = :"measure_#{method_name}"
+      raw_method_name     = :"raw_#{method_name}"
+      self.send(:define_method, measure_method_name) do |*args, &block|
+        parent_uuid  = parent_uuid(options)
+        process_name = "#{self.class.name}##{method_name}"
+        parent       = ProcessMetrics::Base.new(process_name)
+        parent.uuid  = parent_uuid
+
+        ProcessMetrics.measure(process_name, parent) do |metric|
+          ProcessMetrics.logger.debug "About to send #{raw_method_name} with args #{args.inspect} and block #{block.inspect} to #{self}"
+          metric.data = {args: args, block: block}
+
+          send(raw_method_name, *args, &block)
+        end
+      end
+    end
+  end
+
+  def method_added(method_name)
+    return if @@replacing || method_name =~ /^measure_/ || method_name =~ /^raw_/
+    ProcessMetrics.logger.debug "Adding method #{method_name} in #{self}"
+
+    measure_method_name = :"measure_#{method_name}"
+    raw_method_name     = :"raw_#{method_name}"
+
+    if self.instance_methods.include? measure_method_name
+      ProcessMetrics.logger.debug "#{self}##{measure_method_name} exists. Replacing..."
+      @@replacing = true
+      alias_method raw_method_name, method_name
+      alias_method method_name, measure_method_name
+      @@replacing = false
+    else
+      ProcessMetrics.logger.debug "#{self}##{measure_method_name} does not exist. Exiting..."
+    end
+  end
+
+  private
+  def extract_options(array)
+    array.last && array.last.is_a?(Hash) ? array.pop : nil
+  end
+end
+
+module ProcessMetrics
+  module Timer
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def parent_uuid(options)
+      return unless options
+
+      if options[:parent_uuid].respond_to?(:call)
+        # It's a proc. parent_uuid is the return value
+        options[:parent_uuid].call
+      elsif options[:parent_uuid].is_a?(Symbol)
+        # It's a symbol. Call method on object and parent_uuid is its result.
+        send(options[:parent_uuid])
+      else
+        # It's something static. Just call #to_s
+        options[:parent_uuid].to_s
+      end
+    end
+  end
+end

data/lib/process_metrics/version.rb

@@ -0,0 +1,3 @@
+module ProcessMetrics
+  VERSION = "0.1.0"
+end

data/lib/process_metrics.rb

@@ -0,0 +1,18 @@
+require 'process_metrics/base'
+require 'process_metrics/config'
+require 'process_metrics/version'
+require 'process_metrics/timer'
+
+module ProcessMetrics
+  def self.logger
+    config.logger
+  end
+
+  def self.logger=(logger)
+    config.logger = logger
+  end
+
+  def self.measure(name, parent=nil, &block)
+    ProcessMetrics::Base.work(name, parent, &block)
+  end
+end

data/test/test_simple.rb

@@ -0,0 +1,151 @@
+require 'minitest/autorun'
+
+require 'process_metrics'
+
+class MyClass
+  include ProcessMetrics::Timer
+  measure :do_simple_work,
+          :do_work_with_params,
+          :do_work_with_block,
+          :do_work_with_params_and_block
+
+  attr_accessor :my_var
+
+  def initialize(my_var)
+    @my_var = my_var
+  end
+
+  def do_simple_work
+    @my_var += 1
+  end
+
+  def do_work_with_block(&block)
+    block.call(self)
+  end
+
+  def do_work_with_params(user_id)
+    @my_var += user_id + 3
+  end
+
+  def do_work_with_params_and_block(user_id, &block)
+    @my_var += user_id + 5
+    block.call self
+  end
+end
+
+
+class MyChildSymbolClass
+  include ProcessMetrics::Timer
+  measure :do_simple_work,
+          parent_uuid: :parent_object_uuid
+
+  attr_accessor :my_var
+
+  def initialize(my_var)
+    @my_var = my_var
+  end
+
+  def do_simple_work
+    @my_var += 1
+  end
+
+  def parent_object_uuid
+    "fe51cfe1-114f-4516-8c5f-e488e48c3778"
+  end
+end
+
+class MyChildProcClass
+  include ProcessMetrics::Timer
+  measure :do_simple_work,
+          parent_uuid: -> { "b0d50400-cae0-4cc4-b289-f487d3c9b397" }
+
+  attr_accessor :my_var
+
+  def initialize(my_var)
+    @my_var = my_var
+  end
+
+  def do_simple_work
+    @my_var += 1
+  end
+end
+
+class MyChildStringClass
+  include ProcessMetrics::Timer
+  measure :do_simple_work,
+          parent_uuid: "c9b104fb-3389-4c21-b0e9-6c88fd905e4f"
+
+  attr_accessor :my_var
+
+  def initialize(my_var)
+    @my_var = my_var
+  end
+
+  def do_simple_work
+    @my_var += 1
+  end
+end
+
+class TestBlock < Minitest::Test
+  def test_simple_method
+    my_object = MyClass.new(1)
+    my_object.do_simple_work
+
+    assert_equal 2, my_object.my_var
+  end
+
+  def test_method_with_params
+    my_object = MyClass.new(2)
+    my_object.do_work_with_params(3)
+
+    assert_equal 8, my_object.my_var
+  end
+
+  def test_method_with_block
+    my_object = MyClass.new(5)
+
+    my_object.do_work_with_block do |that_object|
+      that_object.my_var += 7
+    end
+
+    assert_equal 12, my_object.my_var
+  end
+
+  def test_method_with_params_and_block
+    my_object = MyClass.new(11)
+
+    my_object.do_work_with_params_and_block(13) do |that_object|
+      that_object.my_var += 17
+    end
+
+    assert_equal 46, my_object.my_var
+  end
+
+  def test_child_symbol_simple_method
+    my_object = MyChildSymbolClass.new(1)
+    my_object.do_simple_work
+
+    assert_equal 2, my_object.my_var
+  end
+
+  def test_child_proc_simple_method
+    my_object = MyChildProcClass.new(1)
+    my_object.do_simple_work
+
+    assert_equal 2, my_object.my_var
+  end
+
+  def test_child_string_simple_method
+    my_object = MyChildStringClass.new(1)
+    my_object.do_simple_work
+
+    assert_equal 2, my_object.my_var
+  end
+
+  def test_block
+    ProcessMetrics.measure('anon') do |metric|
+      sleep rand
+      metric.data = { my_key: 'my_value'}
+    end
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: process_metrics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lucas Uyezu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+- !ruby/object:Gem::Dependency
+  name: pry-debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.3.1
+description: A gem that provides utilities to measure a process and its sub tasks.
+email: lucas@uyezu.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/process_metrics.rb
+- lib/process_metrics/base.rb
+- lib/process_metrics/config.rb
+- lib/process_metrics/persistence.rb
+- lib/process_metrics/persistence/logger.rb
+- lib/process_metrics/timer.rb
+- lib/process_metrics/version.rb
+- test/test_simple.rb
+homepage: https://github.com/lucasuyezu/process_metrics
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Process metrics
+test_files:
+- test/test_simple.rb