redis_syslog 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b412edcf43c1d2b439f46717d4c5af955225202
-  data.tar.gz: feff4048fc2c079a933cd3c42e588f57c8b7365e
+  metadata.gz: afb4ce6ef888935609d8323c018383c5bba18948
+  data.tar.gz: e33283b271eda2685cfc61e4518fcfa7dd782b0f
 SHA512:
-  metadata.gz: 2a0c832ecc5d42bb1b3630a836e0b87df7d16b1018cbb1dd0855c317418f1cec4f982d3e763d7c609b11de5930a194489992a4a11c0e004f871371f22862f545
-  data.tar.gz: 9473eedef0f8ee10ecb0971a7024bf9c5a19b06ccbb6f400e8db7c4d56808101df35b5bd327474509f759bcc5c31f228f1c3fe80103bfeb7b80fdb1bdc3b6e99
+  metadata.gz: a7c2811eb787f44dd9531c34ebd60834b923cef06be335673e047f380468aca8ef5ddb3b3f6a4da35e6d7aab3addc137457b534203accfdaffbd06bd12fb5313
+  data.tar.gz: 2803508c6873e78f71b86aeaea24fda32e2eeabacd89266448d7dea35b60b858631b3280ab2188f3ccce7667f1acb372166ad4d842d7dc9b78117c1dbbbe16e5

data/README.md

@@ -17,23 +17,44 @@ gem 'redis_syslog'
 @redis = Redis.new
 
 #Create an instance of RedisSyslog 
-@logger = RedisSyslog.new redisrb: @redis, namespace: "com.fittr.periodic"
+@logger = RedisSyslog.new @redis
 ```
 
 3. Profit
  ```ruby
-#Write a new entry
-@logger.write "This is my message"
+#Write a new entry to the com.bar.sobriety namespace log
+@logger.write "com.bar.sobriety", "Ordered a beer"
+@logger.write "com.bar.sobriety", "Hiccup!"
 
-#Get last 1 entry
-@logger.last_n_entries(1) #[{:time=>TimeClass, :message => "This is my message"]
+#Get last 2 entries
+puts @logger.tail "com.bar.sobriety", 2
+>[{:index => 1, :timestamp=>2014-1027 18:48:28 -0400, :message => "Hiccup!"},
+   {:index => 0, :timestamp=>2014-1027 18:48:28 -0400, :message => "Ordered a beer"}]
 
-#Delete all entries
-@logger.delete!
+#View all namespaces used
+puts @logger.namespaces ["com.bar.sobriety"]
+
+#Drop this namespace
+@logger.delete "com.bar.sobriety"
+
+#Delete all data including indexes
+@logger.drop_all
 ```
 
-That's it.  That's the entire API.
+There are no limits on the number of logs (namespaces) you can have.
+
+How is it stored?
 ------------
-How is it stored?  Simple.  Each namespace uses the one key with a redis sorted set.  The key follows this format.
+Each namespace (i.e. each log name) uses the one key with a redis sorted set. `` redis_syslog://#{namespace} ``<br />
+Then, we have one index key which contains an unsorted set of keys. `` redis_syslog://namespaces ``
+
+For each entry in the sorted set of some namespace, we follow the simple protocol.
+```ruby
+ ###########################################################################
+ #index     - Number that should be monotonically increasing for each entry
+ #timestamp - A time in seconds from unix epoch
+ #message   - Your message
+ ###########################################################################
+ @encoded_message = "#{index}\n#{timestamp}\n#{message}"
+```
 
-`` redis_syslog://#{namespace} ``

data/lib/redis_syslog.rb

@@ -1,40 +1,87 @@
 require "redis_syslog/version"
 
+module RedisSyslog::MessageEncoder
+  #Encode a message with a timestamp fit for inserting into a redis set.  This must include the index itself because
+  #a non-unique message could end up getting ignored by redis because it's technically a duplicate if the timestamp
+  #happened to be the same.
+  #We're encoding to INDEX\nTIMESTAMP\nMESSAGE
+  def self.encode(index:, timestamp:, message:)
+    "#{index}\n#{timestamp}\n#{message}"
+  end
+
+  def self.decode(data)
+    info = data.split("\n")
+    index = info.shift.to_i
+    timestamp = info.shift.to_i
+
+    #Retrieve by inverting the rest
+    message = data.gsub(self.encode(index: index, timestamp: timestamp, message:""), "")
+
+    return {index: index, timestamp: timestamp, message: message}
+  end
+end
+
 class RedisSyslog::RedisSyslog
   PREFIX = "redis_syslog://"
+  NAMESPACES_LIST_KEY = "redis_syslog://namespaces" #A list of used namespaces
 
-  def self.list_used_namespaces
-    #Return a list of used namespaces
+  #First N characters of key are magic random characters because we are using a sorted set
+  #to store these lists and redis will not allow two duplicate entries (even with different scores)
+  RANDOM_WORD_PREFIX_CHARACTER_COUNT = 8
+
+  #List currently used namespaces
+  def namespaces
+    return @redis.smembers NAMESPACES_LIST_KEY
   end
 
-  def initialize(redisrb:, namespace:)
-    @redis = redisrb
-    @namespace = namespace
+  def initialize(redis)
+    @redis = redis
   end
 
   #This is the actual list key
-  def _key
-    return "#{PREFIX}#{@namespace}"
+  def _key_for_namespace namespace
+    return "#{PREFIX}#{namespace}"
+  end
+
+  def delete namespace
+    @redis.del _key_for_namespace(namespace)
+    @redis.srem NAMESPACES_LIST_KEY, namespace
   end
 
-  def delete!
-    @redis.del _key
+  def drop_all
+    self.namespaces.each do |namespace|
+      self.delete namespace
+    end
+
+    #For good measure
+    @redis.del NAMESPACES_LIST_KEY
   end
 
-  def last_n_entries n
+  def tail namespace, n=1
     raise "n cannot be 0" unless n > 0
     #Return the last N entries of this log
-    results = @redis.zrevrange _key, 0, n-1, :with_scores => true
-    results = results.map{|e| {:time => Time.at(e[1]), :message => e[0][8..-1]} }
+    results = @redis.zrevrange _key_for_namespace(namespace), 0, n-1
+
+    results.map! do |result|
+      result = RedisSyslog::MessageEncoder.decode result
+      result[:timestamp] = Time.at(result[:timestamp].to_i)
+      result
+    end
+
+    results
   end
 
-  def write message
-    @redis.zadd _key, Time.now.to_i, "#{[*('A'..'Z')].sample(8).join}#{message}"
+  def write namespace, message
+    index = @redis.zcard(_key_for_namespace(namespace))
+    encoded_message = RedisSyslog::MessageEncoder.encode index: @redis.zcard(_key_for_namespace(namespace)), timestamp: Time.now.to_i, message: message
+
+    @redis.zadd _key_for_namespace(namespace), index, encoded_message
+    @redis.sadd NAMESPACES_LIST_KEY, namespace
   end
 end
 
 module RedisSyslog
-  def self.new(redisrb:, namespace:)
-    return RedisSyslog.new redisrb: redisrb, namespace: namespace
+  def self.new(redis)
+    return RedisSyslog.new redis
   end
 end

data/lib/redis_syslog/version.rb

@@ -1,3 +1,3 @@
 module RedisSyslog
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_syslog
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Seo Townsend