pulse-meter-client-backport 0.1.0

data/.gitignore

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

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.2-p290

data/.rspec

@@ -0,0 +1 @@
+--color -fd

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.8.7-p357

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ilya Averyanov
+
+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/Procfile

@@ -0,0 +1,3 @@
+watch_coffee: bundle exec rake coffee:watch
+web_sample: bundle exec rackup examples/basic.ru
+sensor_sample: bundle exec ruby examples/basic_sensor_data.rb

data/README.md

@@ -0,0 +1,98 @@
+[![Build Status](https://secure.travis-ci.org/savonarola/pulse-meter-client-backport.png)]
+(http://travis-ci.org/savonarola/pulse-meter-client-backport)
+
+# PulseMeter
+
+PulseMeter is a gem for fast and convenient realtime aggregating of software internal stats through Redis.
+This is a client part of it backported for ruby 1.8.x. It allows to create sensors and send data to them, but
+neither reduce nor visualize.
+
+It is supposed to use a standalone newer installation of ruby to perform reducing and visualisation.
+
+## Client usage
+
+Just create sensor objects and write data. Some examples below.
+
+    require 'pulse-meter'
+    PulseMeter.redis = Redis.new
+
+    # static sensor examples
+
+    counter = PulseMeter::Sensor::Counter.new :my_counter
+    counter.event(1)
+    counter.event(2)
+    puts counter.value
+    # prints
+    # 3
+
+    indicator = PulseMeter::Sensor::Indicator.new :my_value
+    indicator.event(3.14)
+    indicator.event(2.71)
+    puts indicator.value
+    # prints
+    # 2.71
+
+    hashed_counter = PulseMeter::Sensor::HashedCounter.new :my_h_counter
+    hashed_counter.event(:x => 1)
+    hashed_counter.event(:y => 5)
+    hashed_counter.event(:y => 1)
+    p hashed_counter.value
+    # prints
+    # {"x"=>1, "y"=>6}
+
+    # timeline sensor examples
+
+    requests_per_minute = PulseMeter::Sensor::Timelined::Counter.new(:my_t_counter,
+      :interval => 60,         # count for each minute
+      :ttl => 24 * 60 * 60     # keep data one day
+    )
+    requests_per_minute.event(1)
+    requests_per_minute.event(1)
+    sleep(60)
+    requests_per_minute.event(1)
+    requests_per_minute.timeline(2 * 60).each do |v|
+      puts "#{v.start_time}: #{v.value}"
+    end
+    # prints somewhat like
+    # 2012-05-24 11:06:00 +0400: 2
+    # 2012-05-24 11:07:00 +0400: 1
+
+    max_per_minute = PulseMeter::Sensor::Timelined::Max.new(:my_t_max,
+      :interval => 60,         # max for each minute
+      :ttl => 24 * 60 * 60     # keep data one day
+    )
+    max_per_minute.event(3)
+    max_per_minute.event(1)
+    max_per_minute.event(2)
+    sleep(60)
+    max_per_minute.event(5)
+    max_per_minute.event(7)
+    max_per_minute.event(6)
+    max_per_minute.timeline(2 * 60).each do |v|
+      puts "#{v.start_time}: #{v.value}"
+    end
+    # prints somewhat like
+    # 2012-05-24 11:07:00 +0400: 3.0
+    # 2012-05-24 11:08:00 +0400: 7.0
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pulse-meter-client-backport'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pulse-meter-client-backport
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,53 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require "yard"
+require 'yard/rake/yardoc_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+YARD::Rake::YardocTask.new(:yard)
+
+ROOT = File.dirname(__FILE__)
+
+task :default => :spec
+
+namespace :coffee do
+	desc "Complile coffee to js"
+	task :compile do
+		system 'coffee', '-c', "#{ROOT}/lib/pulse-meter/visualize/public/"
+		puts "Done"
+	end
+
+	desc "Watch coffee files and recomplile them immediately"
+	task :watch do
+		system 'coffee', '--watch', '-c', "#{ROOT}/lib/pulse-meter/visualize/public/"
+	end
+
+end
+
+namespace :yard do
+  desc "Open doc index in a browser"
+  task :open do
+    system 'open', "#{ROOT}/doc/index.html"
+  end
+end
+
+namespace :example do
+  desc "Run minimal example"
+  task :minimal do
+    chdir(ROOT) do
+      system "bundle"
+      system "cd examples/minimal && bundle exec foreman start"
+    end
+  end
+
+  desc "Run full example"
+  task :full do
+    chdir(ROOT) do
+      system "bundle"
+      system "cd examples/full && bundle exec foreman start"
+    end
+  end
+
+end

data/bin/pulse

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '../lib/'))
+require 'pulse-meter'
+require 'cmd'
+
+Cmd::All.start

data/examples/readme_client_example.rb

@@ -0,0 +1,52 @@
+$: << File.join(File.absolute_path(__FILE__), '..', 'lib')
+
+require 'pulse-meter'
+PulseMeter.redis = Redis.new
+
+# static sensor examples
+
+counter = PulseMeter::Sensor::Counter.new :my_counter
+counter.event(1)
+counter.event(2)
+puts counter.value
+
+indicator = PulseMeter::Sensor::Indicator.new :my_value
+indicator.event(3.14)
+indicator.event(2.71)
+puts indicator.value
+
+hashed_counter = PulseMeter::Sensor::HashedCounter.new :my_h_counter
+hashed_counter.event(:x => 1)
+hashed_counter.event(:y => 5)
+hashed_counter.event(:y => 1)
+p hashed_counter.value
+
+
+# timeline sensor examples
+
+requests_per_minute = PulseMeter::Sensor::Timelined::Counter.new(:my_t_counter,
+  :interval => 60,         # count for each minute
+  :ttl => 24 * 60 * 60     # keep data one day
+)
+requests_per_minute.event(1)
+requests_per_minute.event(1)
+sleep(60)
+requests_per_minute.event(1)
+requests_per_minute.timeline(2 * 60).each do |v|
+  puts "#{v.start_time}: #{v.value}"
+end
+
+max_per_minute = PulseMeter::Sensor::Timelined::Max.new(:my_t_max,
+  :interval => 60,         # max for each minute
+  :ttl => 24 * 60 * 60     # keep data one day
+)
+max_per_minute.event(3)
+max_per_minute.event(1)
+max_per_minute.event(2)
+sleep(60)
+max_per_minute.event(5)
+max_per_minute.event(7)
+max_per_minute.event(6)
+max_per_minute.timeline(2 * 60).each do |v|
+  puts "#{v.start_time}: #{v.value}"
+end

data/lib/pulse-meter.rb

@@ -0,0 +1,17 @@
+require "redis"
+require "pulse-meter/version"
+require "pulse-meter/mixins/dumper"
+require "pulse-meter/mixins/utils"
+require "pulse-meter/sensor"
+
+module PulseMeter
+  @@redis = nil
+
+  def self.redis
+    @@redis 
+  end
+
+  def self.redis=(redis)
+    @@redis = redis
+  end
+end

data/lib/pulse-meter/mixins/dumper.rb

@@ -0,0 +1,76 @@
+require 'yaml'
+
+module PulseMeter
+  module Mixins
+    # Mixin with dumping utilities
+    module Dumper
+      # Prefix for Redis keys with dumped sensors' metadata
+      DUMP_REDIS_KEY = "pulse_meter:dump"
+
+      module InstanceMethods
+        # Serializes object and saves it to Redis
+        # @raise [DumpError] if dumping fails for any reason
+        def dump!
+          ensure_storability!
+          serialized_obj = self.to_yaml
+          redis.hset(DUMP_REDIS_KEY, self.name, serialized_obj)
+        rescue
+          raise DumpError, "object cannot be dumped"
+        end
+
+        # Ensures that object is dumpable
+        # @raise [DumpError] if object cannot be dumped
+        def ensure_storability!
+          raise DumpError, "#name attribute must be readable" unless self.respond_to?(:name)
+          raise DumpError, "#redis attribute must be available" unless self.respond_to?(:redis) && self.redis
+        end
+        
+        # Cleans up object dump in Redis 
+        def cleanup_dump
+          redis.hdel(DUMP_REDIS_KEY, self.name)
+        end
+      end
+
+      module ClassMethods
+        # Restores object from Redis
+        # @param name [String] object name
+        # @return [Object]
+        # @raise [RestoreError] if object cannot be restored for any reason
+        def restore(name)
+          serialized_obj = PulseMeter.redis.hget(DUMP_REDIS_KEY, name)
+          YAML::load(serialized_obj)
+        rescue
+          raise RestoreError, "cannot restore #{name}"
+        end
+
+        # Lists all dumped objects' names
+        # @return [Array<String>]
+        # @raise [RestoreError] if list cannot be retrieved for any reason
+        def list_names
+          PulseMeter.redis.hkeys(DUMP_REDIS_KEY)
+        rescue
+          raise RestoreError, "cannot get data from redis"
+        end
+
+        # Safely restores all dumped objects
+        # @return [Array<Object>]
+        def list_objects
+          objects = []
+          list_names.each do |name|
+            begin
+              objects << restore(name)
+            rescue
+            end
+          end
+          objects
+        end
+      end
+
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend, ClassMethods
+      end
+
+    end
+  end
+end

data/lib/pulse-meter/mixins/utils.rb

@@ -0,0 +1,93 @@
+require 'securerandom'
+
+module PulseMeter
+  module Mixins
+    # Mixin with various useful functions 
+    module Utils
+      # Tries to find a class with the name specified in the argument string
+      # @param const_name [String] class name
+      # @return [Class] if given class definde
+      # @return [NilClass] if given class is not defined
+      def constantize(const_name)
+        return unless const_name.respond_to?(:to_s)
+        const_name.to_s.split('::').reduce(Module, :const_get)
+      rescue NameError
+        nil
+      end
+
+      # Ensures that hash value specified by key can be converted to positive integer.
+      # In case it can makes in-place conversion and returns the value.
+      # @param options [Hash] hash to be looked at
+      # @param key [Object] hash key
+      # @param default [Object] default value to be returned
+      # @raise [ArgumentError] unless value is positive integer
+      # @return [Fixnum]
+      def assert_positive_integer!(options, key, default = nil)
+        value = options[key] || default
+        raise ArgumentError, "#{key} should be defined" unless value
+        raise ArgumentError, "#{key} should be integer" unless value.respond_to?(:to_i)
+        raise ArgumentError, "#{key} should be positive" unless value.to_i > 0
+        options[key] = value.to_i
+      end
+
+      # Ensures that hash value specified by key is can be converted to float
+      # and it is within given range.
+      # In case it can makes in-place conversion and returns the value.
+      # @param options [Hash] hash to be looked at
+      # @param key [Object] hash key
+      # @param from [Float] lower bound
+      # @param to [Float] upper bound
+      # @raise [ArgumentError] unless value is float within given range
+      # @return [Float]
+      def assert_ranged_float!(options, key, from, to)
+        f = options[key]
+        raise ArgumentError, "#{key} should be defined" unless f
+        raise ArgumentError, "#{key} should be float" unless f.respond_to?(:to_f)
+        f = f.to_f
+        raise ArgumentError, "#{key} should be between #{from} and #{to}" unless f >= from && f <= to
+        options[key] = f
+      end
+
+      # Generates uniq random string
+      # @return [String]
+      def uniqid
+        SecureRandom.hex(32)
+      end
+
+      # Capitalizes the first letter of each word in string
+      # @param str [String]
+      # @return [String]
+      # @raise [ArgumentError] unless passed value responds to to_s
+      def titleize(str)
+        raise ArgumentError unless str.respond_to?(:to_s)
+        str.to_s.split(/[\s_]+/).map(&:capitalize).join(' ')
+      end
+
+      # Converts string from snake_case to CamelCase
+      # @param str [String] string to be camelized
+      # @param first_letter_upper [TrueClass, FalseClass] says if the first letter must be uppercased
+      # @return [String]
+      # @raise [ArgumentError] unless passed value responds to to_s
+      def camelize(str, first_letter_upper = false)
+        raise ArgumentError unless str.respond_to?(:to_s)
+        terms = str.to_s.split(/_/)
+        first = terms.shift
+        (first_letter_upper ? first.capitalize : first.downcase) + terms.map(&:capitalize).join
+      end
+
+      # Deeply capitalizes Array values or Hash keys
+      def camelize_keys(item)
+        case item
+          when Array
+            item.map{|i| camelize_keys(i)}
+          when Hash
+            h = {}
+            item.each{ |k, v| h[camelize(k)] = camelize_keys(v)}
+            h
+        else
+          item
+        end
+      end
+    end
+  end
+end