simple_events_redis 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzRlMWU0MjUxNGIxYmFiZTBiN2YzMDYyZjdkN2Q1NTA3ZDdhYzFlOQ==
+  data.tar.gz: !binary |-
+    NzFlOGMwOWVhNWZkMDdmNWFkNDA1MDJhOTYxMjAxYWI5MDViZGM1ZA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YzQ0ZjgyZGE0NGVhZWQwYjgxZjBjMmFiOThlYTFiZjZjZTVlZWFlZGRjOGRi
+    MzdjMzUwOGRkYTI5NzZiMTVjMTNmMjIyMTkwZjE5ZWRlNDk2ODVmN2IzYjM4
+    ZDZhYjI2NmE0MTczYjBiOWM5YTRkMDZlNWJiZmM5NjA0MGRlYzA=
+  data.tar.gz: !binary |-
+    YjdjOTBhNWRmMDNlZTQ0OTViMGNlOTQzMDViMzZkZDU5ODk4ODVkNmYyMzkx
+    ZjU0ODNiNDU1N2E5MDA0ODk4NGM3OWYyODliNWExYzM2M2VlMTVmMDk2NmNi
+    ZTA1MTdjNTI2NmMzOGNiNjNhYmJkYWI5MTk2MmRlODVhNzRhMTA=

data/README.md

@@ -0,0 +1,41 @@
+# Simple tracking of custom events
+
+
+Library to store custom data in lists by days in Redis.
+Old data is automatically removed.
+Useful for debugging and tracking different events in application.
+
+
+## Overview
+Data is stored in Redis in lists with names:
+<<YOUR_SITE_NAME>> : lists : <list_name> : <day> - Redis list
+
+for example,
+
+    mysite:lists:mylist:20130407 - list for day April 04, 2013
+
+
+## Installation
+
+It uses gem 'redis' and relies on $redis global variable to access Redis server.
+
+in Rails application:
+
+    gem 'redis'
+    gem 'lists_by_days_redis'
+
+
+
+Setup:
+
+initializer:
+
+    ListsByDaysRedis::List::SITE_NAME = 'mysite'
+    ListsByDaysRedis::List::EXPIRE_DAYS = 7
+
+
+
+## Add new item to list
+
+
+

data/lib/events.rb

@@ -0,0 +1,348 @@
+module SimpleEventsRedis
+
+  require 'redis'
+
+  class Events
+    # static data
+    #PROCESSES = ['effects']
+    SITE_NAME = ''
+
+    EXPIRE_DAYS = 7
+
+
+    @@redis = nil
+
+    # redis object to access Redis server
+    def self.redis
+      return @@redis unless @redis.nil?
+
+      # init by global object
+      unless $redis.nil?
+        @@redis = $redis
+        return @@redis
+      end
+
+
+      # default
+      @@redis = Redis.new(:host => 'localhost', :port => 6379)
+
+      @@redis
+    end
+
+    # methods for any log_type add_<<ANY_LOG_TYPE>>
+    def self.method_missing(method_name, *args, &block)
+      if method_name.to_s =~ /^log_(.+)$/
+        self.log($1, *args)
+      else
+        super
+      end
+    end
+
+
+    # logging
+
+    def self.log(log_name, data={})
+      t = Time.now.utc.to_i
+      rkey = self.redis_key_log log_name
+
+      #
+      hash = {:created=>t}
+      if data.is_a?(Hash)
+        data.each_pair { |k,v| hash["#{k}"] = v }
+      elsif data.is_a?(String)
+        hash["msg"] = data
+      else
+        hash["msg"] = "#{data.inspect}"
+      end
+
+      #
+      require 'json'
+      s = JSON.generate(hash)
+
+      redis.rpush rkey, s
+      redis.expireat rkey, t+EXPIRE_DAYS*24*60*60
+
+      return true
+    end
+
+
+    def self.log_event(log_name, event_name, msg, data={})
+      data['event'] = event_name
+      data['msg'] = msg
+      return self.log log_name, data
+    end
+
+    #
+    def self.debug(event_name, msg, data={})
+      data['event'] = event_name
+      data['msg'] = msg
+      return self.log 'debug', data
+    end
+
+
+
+    def self.get_logs(log_name, n_days_back=-1, filter={})
+      all_keys = redis.keys(self.redis_key_log_prefix + "#{log_name}:" +'*')
+
+      return [] if all_keys.nil?
+
+      require 'json'
+
+      tnow = Time.now.utc.to_i
+      rows = []
+      all_keys.each do |rkey|
+        day = self.parse_date rkey
+
+        # if cannot parse key
+        next if day.nil?
+
+        # if not too old day
+        if n_days_back>0
+          next if tnow - day.to_i > n_days_back * (60*60*24)
+        end
+
+        # get all items from the list
+        values = redis.lrange rkey, 0, 100000
+
+        values.each do |v|
+          #r = Marshal.load v
+          r = JSON.parse(v)
+
+          # filter
+          is_good = true
+
+          unless filter.nil? && filter.is_a?(Hash)
+            filter.each_pair do |field_name, field_value|
+              if r[field_name].nil?
+                is_good = false
+                break
+              end
+              if r[field_name] != field_value
+                is_good = false
+                break
+              end
+            end
+          end
+
+          # add to result
+          if is_good
+            rows << r
+          end
+        end
+
+      end
+
+      rows
+    end
+
+
+
+
+
+    # status
+    def self.status_set(event_name)
+      redis.hset self.redis_key_status, event_name, Time.now.utc.to_i
+
+      return true
+    end
+
+    def self.get_status(event_name, v_def=nil)
+      v = redis.hget self.redis_key_status, event_name
+      v ||= v_def
+      v
+    end
+
+    def self.get_statuses(pattern='*')
+      # event_names like 'name*'
+
+      rows = []
+
+      all_values = redis.hgetall self.redis_key_status
+
+      all_values.each do |event, v|
+        rows << {:site=>SITE_NAME, :event=>event, :v=>v}
+      end
+
+      rows
+    end
+
+
+
+    # counters
+
+    def self.stat_add(event_name, n=1)
+      redis.hincrby self.redis_key_stat, event_name, n
+
+      return true
+    end
+
+    def self.stat_add_perf(event_name, duration_secs, n=1)
+      redis.hincrby self.redis_key_stat, event_name+'_time', (duration_secs*1000).floor
+      redis.hincrby self.redis_key_stat, event_name+'_n', 1
+
+      return 1
+    end
+
+
+    def self.get_stats(n_days_back=1)
+      rows = []
+
+      self.stat_walk(n_days_back, 0) do |key, day|
+        all_values = redis.hgetall key
+
+        all_values.each do |event, v|
+          rows << {:site=>SITE_NAME, :created=>day.to_i, :event=>event, :amount=>v.to_i}
+        end
+      end
+
+      rows
+    end
+
+
+
+
+    # helper methods
+
+    def self.redis_key_prefix
+      "#{SITE_NAME=='' ? '' : SITE_NAME+':'}"
+    end
+
+    def self.key_day(d=nil)
+      d ||= DateTime.now.new_offset(0)
+
+      d.strftime("%Y%m%d")
+    end
+
+
+    # redis keys for log
+    def self.redis_key_log_prefix
+      self.redis_key_prefix + "log:"
+    end
+
+    def self.redis_key_log(name)
+      self.redis_key_log_prefix + "#{name}:" + self.key_day
+    end
+
+
+    # redis keys for status
+
+    def self.redis_key_status
+      self.redis_key_prefix + 'status'
+    end
+
+
+    # redis keys for stat
+
+    def self.redis_key_stat_prefix
+      self.redis_key_prefix + 'stat:'
+    end
+
+    def self.redis_key_stat
+      self.redis_key_stat_prefix + self.key_day
+    end
+
+
+    #
+    def self.parse_date(s)
+      # parse key
+      mm = s.scan(/(\d\d\d\d)(\d\d)(\d\d)$/i)
+
+      return nil if mm.nil? || mm[0].nil?
+
+      y, m, d = mm[0].map{|v| v.to_i}
+
+      Time.utc(y,m,d)
+    end
+
+
+
+    # clear data
+
+    def self.clear_logs_all
+      keys = redis.keys self.redis_key_log_prefix + '*'
+      return if keys.empty?
+      redis.del keys
+    end
+
+    def self.clear_logs(name)
+      keys = redis.keys self.redis_key_log_prefix+"#{name}:*"
+      return if keys.empty?
+      redis.del keys
+    end
+
+    # TODO:
+    def self.clear_logs_old(name)
+
+    end
+
+
+    # clear status
+
+    def self.clear_status_all
+      rkey = self.redis_key_status
+
+      redis.del rkey
+    end
+
+
+
+    # clear stats
+
+    def self.clear_stats_all
+      keys = redis.keys self.redis_key_stat_prefix+"*"
+      return if keys.empty?
+      redis.del keys
+    end
+
+
+    # clear data older than n_days_back
+    def self.clear_stats_old(n_days_back=1)
+      rows = []
+
+      # all days older than N days
+      self.stat_walk(-1, n_days_back) do |key, day|
+        redis.del key
+      end
+
+      rows
+    end
+
+
+    def self.stat_walk(n_days_back_from, n_days_back_to)
+
+      tnow = Time.now.utc_to_i
+
+      key_prefix = self.redis_key_stat_prefix
+      keys = redis.keys key_prefix + "*"
+
+      keys.each do |key|
+        # parse key
+        mm = key.scan(/#{key_prefix}:(\d+)$/i)
+
+        next if mm.nil? || mm[0].nil?
+
+        day = self.parse_date(mm[0][0])
+
+        next if day.nil?
+
+        # too old
+        if n_days_back_from>=0
+          next if tnow - day.to_i > n_days_back_from * (60*60*24)
+        end
+
+        # too fresh
+        if n_days_back_to>=0
+          next if tnow - day.to_i < n_days_back_to * (60*60*24)
+        end
+
+        # do the work
+        yield(key, day)
+
+      end
+    end
+
+  end
+
+
+end
+

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: simple_events_redis
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- ! 'Max Ivak '
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-09 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email:
+- maxivak@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/events.rb
+- README.md
+homepage: https://github.com/maxivak/simple_events_redis/
+licenses: []
+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.3
+signing_key: 
+specification_version: 4
+summary: ! 'Library to track events: counters of events, logging, state monitoring.
+  Data is stored in Redis'
+test_files: []