pulse_meter_core 0.4.13

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.3-p125

data/.rspec

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+branches:
+  only:
+    - master
+    - develop

data/Gemfile

@@ -0,0 +1,2 @@
+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/README.md

@@ -0,0 +1,40 @@
+[![Gem Version](https://badge.fury.io/rb/pulse_meter_core.png)](http://badge.fury.io/rb/pulse_meter_core)
+[![Build Status](https://secure.travis-ci.org/savonarola/pulse_meter_core.png)](http://travis-ci.org/savonarola/pulse_meter_core)
+[![Dependency Status](https://gemnasium.com/savonarola/pulse_meter_core.png)](https://gemnasium.com/savonarola/pulse_meter_core)
+[![Code Climate](https://codeclimate.com/github/savonarola/pulse_meter_core.png)](https://codeclimate.com/github/savonarola/pulse_meter_core)
+
+# PulseMeter
+
+PulseMeter is a gem for fast and convenient realtime aggregating of software internal stats through Redis.
+
+## Live Demo
+
+A small live demo of [pulse-meter](https://github.com/savonarola/pulse-meter) gem is located here: [rubybox.ru](http://rubybox.ru), its source code can be found here: [https://github.com/savonarola/pulse-meter-demo](https://github.com/savonarola/pulse-meter-demo)
+
+## Features
+
+Gem contains core functionality for [pulse-meter](https://github.com/savonarola/pulse-meter) gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pulse_meter_core'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pulse_meter_core
+
+## 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,20 @@
+#!/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 :yard do
+  desc "Open doc index in a browser"
+  task :open do
+    system 'open', "#{ROOT}/doc/index.html"
+  end
+end

data/lib/pulse_meter/command_aggregator/async.rb

@@ -0,0 +1,83 @@
+require 'singleton'
+require 'thread'
+
+module PulseMeter
+  module CommandAggregator
+    class Async
+      include Singleton
+
+      MAX_QUEUE_LENGTH = 10_000
+
+      attr_reader :max_queue_length
+
+      def initialize
+        @max_queue_length = MAX_QUEUE_LENGTH
+        @queue = Queue.new
+        @buffer = []
+        @in_multi = false
+        @consumer_thread = run_consumer
+        at_exit{ wait_for_pending_events }
+      end
+
+      def multi
+        @in_multi = true
+        yield
+      ensure
+        @in_multi = false
+        send_buffer_to_queue
+      end
+
+      def method_missing(*args)
+        @buffer << args
+        send_buffer_to_queue unless @in_multi
+      end
+
+      def wait_for_pending_events(max_seconds = 1)
+        left_to_wait = max_seconds.to_f
+        sleep_step = 0.01
+        while has_pending_events? && left_to_wait > 0
+          left_to_wait -= sleep_step
+          sleep(sleep_step)
+        end
+      end
+
+      private
+
+      def has_pending_events?
+        !@queue.empty?
+      end
+
+      def send_buffer_to_queue
+        if @queue.size < @max_queue_length
+          @queue << @buffer
+        end
+        @buffer = []
+      end
+
+      def redis
+        PulseMeter.redis
+      end
+
+      def consume_commands
+        # redis and @queue are threadsafe
+        while commands = @queue.pop
+          begin
+            redis.multi do 
+              commands.each do |command|
+                redis.send(*command)
+              end
+            end
+          rescue StandardError => e
+            PulseMeter.error "error in consumer thread: #{e}, #{e.backtrace.join("\n")}"
+          end
+        end
+      end
+
+      def run_consumer
+        Thread.new do
+          consume_commands
+        end
+      end
+    end
+  end
+end

data/lib/pulse_meter/command_aggregator/sync.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+
+module PulseMeter
+  module CommandAggregator
+    class Sync
+      include Singleton
+
+      def redis
+        PulseMeter.redis
+      end
+
+      def method_missing(*args, &block)
+        redis.send(*args, &block)
+      end
+    end
+  end
+end
+

data/lib/pulse_meter/command_aggregator/udp.rb

@@ -0,0 +1,48 @@
+require 'socket'
+require 'fcntl'
+
+module PulseMeter
+  module CommandAggregator
+    class UDP
+
+      def initialize(host, port = nil)
+        @servers = if host.is_a?(Array)
+          host
+        else
+          [[host, port]]
+        end
+        raise ArgumentError, "No servers specified" if @servers.empty?
+        @buffer = []
+        @in_multi = false
+        @sock = UDPSocket.new
+        @sock.fcntl(Fcntl::F_SETFL, @sock.fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+      end
+
+      def multi
+        @in_multi = true
+        yield
+      ensure
+        @in_multi = false
+        send_buffer
+      end
+
+      def method_missing(*args)
+        @buffer << args
+        send_buffer unless @in_multi
+      end
+
+      private
+
+      def send_buffer
+        data = @buffer.to_json
+        @sock.send(data, 0, *@servers.sample)
+      rescue StandardError => e
+        PulseMeter.error "error sending data: #{e}, #{e.backtrace.join("\n")}"
+      ensure
+        @buffer = []
+      end
+
+    end
+  end
+end
+

data/lib/pulse_meter/mixins/dumper.rb

@@ -0,0 +1,87 @@
+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
+        # @param safe [Boolean] forbids dump if sensor has already been dumped
+        # @raise [DumpConflictError] if object class conflicts with stored object class
+        # @raise [DumpError] if dumping fails for any reason
+        def dump!(safe = true)
+          ensure_storability!
+          serialized_obj = to_yaml
+          if safe
+            unless redis.hsetnx(DUMP_REDIS_KEY, name, serialized_obj)
+              stored = self.class.restore(name)
+              unless stored.class == self.class
+                raise DumpConflictError, "Attempt to create sensor #{name} of class #{self.class} but it already has class #{stored.class}"
+              end
+            end
+          else
+            redis.hset(DUMP_REDIS_KEY, name, serialized_obj)
+          end
+        rescue DumpError, RestoreError => exc
+          raise exc
+        rescue StandardError => exc
+          raise DumpError, "object cannot be dumped: #{exc}"
+        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
+          list_names.each_with_object([]) do |name, objects|
+            begin
+              objects << restore(name)
+            rescue
+            end
+          end
+        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,155 @@
+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 is Array
+      # @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 Array
+      # @return [Array]
+      def assert_array!(options, key, default = nil)
+        value = options[key] || default
+        raise ArgumentError, "#{key} should be defined" unless value
+        raise ArgumentError, "#{key} should be array" unless value.is_a?(Array)
+        value
+      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
+
+      # Converts string from CamelCase to snake_case
+      # @param str [String] string to be underscore
+      # @return [String]
+      # @raise [ArgumentError] unless passed value responds to to_s
+      def underscore(str)
+        raise ArgumentError unless str.respond_to?(:to_s)
+        str.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+
+      # Converts string of the form YYYYmmddHHMMSS (considered as UTC) to Time
+      # @param str [String] string to be converted
+      # @return [Time]
+      # @raise [ArgumentError] unless passed value responds to to_s
+      def parse_time(str)
+        raise ArgumentError unless str.respond_to?(:to_s)
+        m = str.to_s.match(/\A(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\z/)
+        if m
+          Time.gm(*m.captures.map(&:to_i))
+        else
+          raise ArgumentError, "`#{str}' is not a YYYYmmddHHMMSS time"
+        end
+      end
+
+      # Symbolizes hash keys
+      def symbolize_keys(h)
+        h.each_with_object({}) do |(k, v), acc|
+          new_k = if k.respond_to?(:to_sym)
+            k.to_sym
+          else
+            k
+          end
+          acc[new_k] = v
+        end
+      end
+
+      # Deeply capitalizes Array values or Hash keys
+      def camelize_keys(item)
+        case item
+        when Array
+          item.map{|i| camelize_keys(i)}
+        when Hash
+          item.each_with_object({}) { |(k, v), h| h[camelize(k)] = camelize_keys(v)}
+        else
+          item
+        end
+      end
+      
+      # Yields block for each subset of given array
+      # @param array [Array] given array
+      def each_subset(array)
+        subsets_of(array).each {|subset| yield(subset)}
+      end
+
+      # Returs all array's subsets
+      # @param array [Array]
+      def subsets_of(array)
+        0.upto(array.length).flat_map { |n| array.combination(n).to_a }
+      end
+    end
+  end
+end