nightfury 0.0.1

data/.gitignore

@@ -0,0 +1,80 @@
+.sass-cache/
+.bundle
+public/javascripts/app_error_handler.js
+supportbeeapp_production.sql
+solr/data
+db/*.qlite3
+log/*.log
+tmp/**/*
+config/database.yml
+config/sb_config.yml
+config/secret_config.yml
+tmp/*
+public/javascripts/backbone/**/**/*.js
+public/javascripts/backbone/*.js
+public/javascripts/backbone/collections/
+public/javascripts/backbone/models/
+doc/api
+doc/app
+*.swp
+*.swo
+*.swm
+*.un~
+*˜
+.DS_Store
+schema.rb
+.tags
+emails/*
+public/uploads/*
+public/images/twitter_auth.png
+public/assets
+public/javascripts/backbone/libs/
+public/javascripts/spin.js
+public/javascripts/utility.js
+public/javascripts/admin/
+public/javascripts/backbone-rails.js
+public/javascripts/payments.js
+public/javascripts/widget/script_coffee.js
+public/javascripts/app_error_handler.js
+public/javascripts/sb.apps.js
+public/stylesheets/admin/ie.css
+public/stylesheets/admin/ie6.css
+public/stylesheets/admin/print.css
+public/stylesheets/admin/screen.css
+public/stylesheets/admin/theme.css
+public/stylesheets/app/ie.css
+public/stylesheets/app/ie6.css
+public/stylesheets/app/layout.css
+public/stylesheets/app/screen.css
+public/stylesheets/app/theme.css
+public/stylesheets/app/account.css
+public/stylesheets/app/screen_responsive.css
+public/stylesheets/embed_form.css
+public/stylesheets/formtastic_changes.css
+public/stylesheets/app/email.css
+public/stylesheets/common/marketing.css
+public/stylesheets/common/sprite.css
+public/stylesheets/common/blueprint_tabs.css
+public/stylesheets/widget/
+spec/javascripts/backbone/
+spec/javascripts/admin
+spec/javascripts/UtilitySpec.js
+spec/javascripts/BackboneRailsSpec.js
+spec/javascripts/helpers/SpecHelper.js
+*.swn
+uploads/
+bin/
+lib/daemons/log
+log/
+.sass-cache/
+tags
+.rvmrc
+bundler_stubs/
+*.swg
+*.swh
+*.swi
+*.swj
+*.swk
+*.swl
+public/stylesheets/common/tinymce.css
+public/stylesheets/common/tinymce_ui.css

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gem 'redis', '~> 3.0.0'
+gem 'redis-namespace', '~> 1.2'
+gem 'activesupport', '~> 3.0.0'
+gem 'i18n'
+gem 'json'
+
+gemspec
+
+gem 'rspec'
+gem 'flexmock'
+gem 'mock_redis'
+gem 'timecop'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Avinasha Shastry
+
+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,29 @@
+# Nightfury
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'nightfury'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nightfury
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/example.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'nightfury'
+
+REDIS_CLIENT = Redis.new(:db => 15)
+Redis.current = REDIS_CLIENT
+
+# Defining Identity
+class CompanyIdentity < Nightfury::Identity::Base
+  # Defining metric: 
+  # #metric(name, type)
+  # type defaults to :value
+  metric :first_response_time, :time_series
+  metric :ticket_count
+end
+
+
+time_now = Time.now
+
+# Identity object requires an unique ID
+c = CompanyIdentity.new(1)
+
+# Working with time series
+# #set(value, timestamp)
+# timestamp defaults to current time
+c.first_response_time.set(1) 
+c.first_response_time.set(2,time_now - 10)
+
+# #get([timestamp])
+# without a timestamp get returns the latest value
+# return value is a hash with a key value pair (unix_timestamp, value)
+# all return values are strings regardless of their data type at the time of insertion
+puts "#get; latest value: \n #{c.first_response_time.get}"
+puts "#get(timestamp); value at the timestamp: \n #{c.first_response_time.get(time_now - 10)}"
+puts "#get_range(start_time, end_time); returns values with condition start_time >= value <= end_time \n #{c.first_response_time.get_range(time_now - 15, time_now - 5)}"
+puts "#get_all; returns all values \n #{c.first_response_time.get_all}"
+
+
+# Working with values
+c.ticket_count.set(0)
+# increment by 1
+c.ticket_count.incr
+# increment by 10
+c.ticket_count.incr(10)
+# decrement by 1
+c.ticket_count.decr
+# decrement by 5
+c.ticket_count.decr(5)
+puts "Ticket Count; should be 5 \n #{c.ticket_count.get}"

data/lib/nightfury/identity.rb

@@ -0,0 +1,42 @@
+module Nightfury
+  module Identity
+    class Base
+
+      METRIC_MAPPINGS = {
+            :value => Nightfury::Metric::Value,
+            :time_series => Nightfury::Metric::TimeSeries
+          }
+
+      class << self
+        
+        attr_reader :metrics
+
+        def name
+          self.to_s.demodulize.underscore
+        end
+
+        def metric(name, type = :value)
+          @metrics ||= {}
+          @metrics[name] = {type: type}
+           
+          class_eval <<-ENDOFMETHOD
+            def #{name}
+              @_#{name} ||= METRIC_MAPPINGS[:#{type}].new(:#{name}, redis_key_prefix: key_prefix)
+            end
+          ENDOFMETHOD
+        end
+
+      end
+      
+      attr_accessor :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def key_prefix
+        "#{self.class.name}:#{id}"
+      end
+    end
+  end
+end

data/lib/nightfury/metric/time_series.rb

@@ -0,0 +1,91 @@
+module Nightfury
+  module Metric
+    class TimeSeries < Base
+
+      def initialize(name, options={})
+        super(name, options={})
+        init_time_series unless redis.exists(redis_key)
+      end
+
+      def set(value, time=Time.now)
+        value = before_set(value)
+        # make sure the time_series is initialized.
+        # It will not if the metric is removed and 
+        # set is called on the smae object
+        init_time_series unless redis.exists(redis_key)
+        add_value_to_timeline(value, time)
+      end
+      
+      def get(timestamp=nil)
+        return nil unless redis.exists(redis_key)
+        data_point = ''
+        if timestamp
+          timestamp = timestamp.to_i
+          data_point = redis.zrangebyscore(redis_key, timestamp, timestamp).first
+        else
+          data_point = redis.zrevrange(redis_key, 0, 0).first
+        end
+
+        time, data = decode_data_point(data_point)
+        {time => data}
+      end
+
+      def get_range(start_time, end_time)
+        return nil unless redis.exists(redis_key)        
+        start_time = start_time.to_i
+        end_time = end_time.to_i
+        data_points = redis.zrangebyscore(redis_key, start_time, end_time)
+        decode_many_data_points(data_points)
+      end
+
+      def get_all
+        return nil unless redis.exists(redis_key)        
+        data_points = redis.zrange(redis_key,1,-1)
+        decode_many_data_points(data_points)         
+      end
+
+      def meta
+        json = redis.zrange(redis_key, 0, 0).first
+        JSON.parse(json)
+      end
+
+      def default_meta
+        {}
+      end
+
+      private
+      
+      def add_value_to_timeline(value, time)
+        time = time.to_i
+        value = "#{time}:#{value}"
+        redis.zadd redis_key, time, value
+      end
+
+      def decode_many_data_points(data_points)
+        result = {}
+        data_points.each do |data_point|
+          time, data = decode_data_point(data_point)
+          result[time] = data
+        end
+        result
+      end
+
+      def decode_data_point(data_point)
+        colon_index = data_point.index(':')
+
+        [
+          data_point[0...colon_index], 
+          data_point[colon_index+1..-1]
+        ]
+      end
+
+      def before_set(value)
+        value
+      end
+
+      def init_time_series
+        redis.zadd redis_key, 0, default_meta.to_json
+      end
+    end
+  end
+end

data/lib/nightfury/metric/value.rb

@@ -0,0 +1,28 @@
+module Nightfury
+  module Metric
+    class Value < Base
+      def set(value)
+        value = before_set(value)
+        redis.set(redis_key, value)
+      end
+
+      def get
+        redis.get(redis_key)
+      end
+
+      def incr(step=1)
+        redis.incrby(redis_key, step)
+      end
+    
+      def decr(step=1)
+        redis.decrby(redis_key, step)
+      end
+
+      private
+
+      def before_set(value)
+        value
+      end
+    end
+  end
+end

data/lib/nightfury/metric.rb

@@ -0,0 +1,24 @@
+module Nightfury
+  module Metric
+    class Base      
+      attr_reader :name, :redis, :redis_key_prefix
+      
+      def initialize(name, options={})
+        @name = name
+        @redis = Nightfury.redis
+        @redis_key_prefix = options[:redis_key_prefix]
+      end
+
+      def redis_key
+        prefix = redis_key_prefix.blank? ? '' : "#{redis_key_prefix}:"
+        "#{prefix}metric:#{name}" 
+      end
+
+      def delete
+        redis.del redis_key
+      end
+    end
+  end
+end
+
+

data/lib/nightfury/version.rb

@@ -0,0 +1,3 @@
+module Nightfury
+  VERSION = "0.0.1"
+end

data/lib/nightfury.rb

@@ -0,0 +1,43 @@
+require 'redis'
+require 'redis-namespace'
+require 'json'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/concern'
+
+module Nightfury
+  class << self
+    attr_accessor :redis, :namespace
+
+    def redis
+      @redis ||= set_namespace(Redis.current)
+    end
+
+    def redis=(redis_instance)
+      @redis = set_namespace(redis_instance)
+    end
+
+    def namespace
+      @namespace ||= :nf
+    end
+
+    def namespace=(namespace_symbol)
+      @namespace = namespace_symbol
+      @redis = set_namespace(redis)
+    end
+
+    private
+
+    def set_namespace(redis_instance)
+      Redis::Namespace.new(namespace, redis: redis_instance)
+    end
+  end
+end
+
+require "nightfury/version"
+require "nightfury/metric"
+require "nightfury/metric/value"
+require "nightfury/metric/time_series"
+require "nightfury/identity"
+

data/nightfury.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nightfury/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Avinasha Shastry", "Prateek Dayal"]
+  gem.email         = ["me@avinasha.com", "prateek@supportbee.com"]
+  gem.description   = %q{Nightfury is a reporting/analytics backend written on Redis}
+  gem.summary       = %q{Nightfury is a reporting/analytics backend written on Redis}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "nightfury"
+  gem.require_paths = ["lib"]
+  gem.requirements = ["redis, v3.0.0 or greater"]
+  gem.version       = Nightfury::VERSION
+end

data/spec/nightfury/identity_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Nightfury::Identity::Base do
+
+  class Dummy < Nightfury::Identity::Base
+  end
+
+  describe "ClassMethods" do
+    it "should have a name" do
+      Dummy.name.should == 'dummy'
+    end
+
+    describe "metric" do
+      it "should add to metrics" do
+        Dummy.metric(:count)
+        Dummy.metrics[:count].should == {type: :value}
+      end
+
+      it "should add a instance method" do
+        Dummy.metric(:another_count)
+        Dummy.instance_methods.should include(:another_count)
+      end
+    end
+  end
+
+  describe "InstanceMethods" do
+    it "should have an id" do
+      d = Dummy.new(1)
+      d.id.should == 1
+    end
+
+    it "should generates a key prefix" do
+      d = Dummy.new(1)
+      d.key_prefix.should == 'dummy:1'
+    end
+
+    describe "Dynamically generated metric" do
+      it "should instantiate the right metric class" do
+        Dummy.metric(:third_count)
+        d = Dummy.new(1)
+        metric_object = d.third_count
+        metric_object.should be_kind_of(Nightfury::Metric::Value)
+        metric_object.name.should == :third_count
+        metric_object.redis_key_prefix.should == 'dummy:1'
+      end
+    end
+  end
+end

data/spec/nightfury/metric/time_series_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Nightfury::Metric::TimeSeries do
+  describe "Initialization" do
+    it "should initialize a time series (setup meta data)" do
+      ts_metric = Nightfury::Metric::TimeSeries.new(:avg_time)
+      ts_metric.meta.should == {}
+    end
+  end
+
+  describe "Getter" do
+    describe "#get" do
+      it "should retrun nil if metric key on redis is empty" do
+        ts_metric = Nightfury::Metric::TimeSeries.new(:time)
+        # delete redis key
+        ts_metric.redis.del ts_metric.redis_key
+        ts_metric.get.should be_nil
+      end
+
+      context "without timestamp" do
+        it "should get the most recent data point" do
+          ts_metric = Nightfury::Metric::TimeSeries.new(:time)
+          time_now = Time.now
+          time_later = time_now + 10
+          ts_metric.set(1, time_now)
+          ts_metric.set(2, time_later)
+          result = ts_metric.get
+          result[time_later.to_i.to_s].should == '2'
+        end
+      end
+
+      context "with timestamp" do
+        it "should get the data point at the time stamp" do
+          ts_metric = Nightfury::Metric::TimeSeries.new(:time)
+          time_now = Time.now
+          time_later = time_now + 10
+          ts_metric.set(1, time_now)
+          ts_metric.set(2, time_later)
+          result = ts_metric.get(time_now)
+          result[time_now.to_i.to_s].should == '1'
+        end
+      end
+    end
+
+    describe "#get_range" do
+      it "should retrun nil if metric key on redis is empty" do
+        ts_metric = Nightfury::Metric::TimeSeries.new(:time)
+        # delete redis key
+        ts_metric.redis.del ts_metric.redis_key
+        ts_metric.get_range(Time.now, Time.now).should be_nil
+      end
+
+      it "should get all data points between the specified ranges" do
+        ts_metric = Nightfury::Metric::TimeSeries.new(:time)
+        time = Time.now
+        loop_time = time.dup
+
+        10.times do |i|
+          ts_metric.set(i, loop_time)
+          loop_time = loop_time + 1
+        end
+
+        start_time = time + 3
+        end_time = time + 5
+
+        result = ts_metric.get_range(start_time, end_time)
+        result[start_time.to_i.to_s].should == '3'
+        result[(start_time.to_i + 1).to_s].should == '4'
+        result[end_time.to_i.to_s].should == '5'
+      end
+    end
+
+    describe "#get_all" do
+      it "should retrun nil if metric key on redis is empty" do
+        ts_metric = Nightfury::Metric::TimeSeries.new(:time)
+        # delete redis key
+        ts_metric.redis.del ts_metric.redis_key
+        ts_metric.get_all.should be_nil
+      end
+
+      it "should get all the data points in the series" do
+        ts_metric = Nightfury::Metric::TimeSeries.new(:time)
+        time = Time.now
+        loop_time = time.dup
+
+        10.times do |i|
+          ts_metric.set(i, loop_time)
+          loop_time = loop_time + 1
+        end
+
+        result = ts_metric.get_all
+        result.length.should == 10
+      end
+    end
+  end
+
+  describe "Setter" do
+    describe "add the value to timeline" do
+      it "should default time to current time" do
+        time_now = Time.now 
+        ts_metric = Nightfury::Metric::TimeSeries.new(:avg_time)
+
+        flexmock(ts_metric.redis).should_receive(:zadd)
+                                 .with(ts_metric.redis_key, 
+                                       time_now.to_i, 
+                                       FlexMock.any)
+                                 .once
+
+        Timecop.freeze(time_now) do
+          ts_metric.set(1)
+        end
+        Timecop.return
+      end
+
+      it "should add at specified time" do
+        time = Time.now - 60
+        ts_metric = Nightfury::Metric::TimeSeries.new(:avg_time)
+
+        flexmock(ts_metric.redis).should_receive(:zadd)
+                                 .with(ts_metric.redis_key, 
+                                       time.to_i, 
+                                       FlexMock.any)
+                                 .once
+
+        ts_metric.set(1, time)
+      end
+
+      it "should add the time to the value to avoid duplicate value in the set" do
+        time = Time.now
+        ts_metric = Nightfury::Metric::TimeSeries.new(:avg_time)
+
+        flexmock(ts_metric.redis).should_receive(:zadd)
+                                 .with(FlexMock.any, 
+                                       FlexMock.any, 
+                                       "#{time.to_i}:1")
+                                 .once
+        ts_metric.set(1, time)
+      end
+    end
+  end
+end

data/spec/nightfury/metric/value_spec.rb

@@ -0,0 +1,25 @@
+describe Nightfury::Metric::Value do
+  it "should get a value by delegating to redis" do
+    value_metric = Nightfury::Metric::Value.new(:tickets_count)
+    flexmock(value_metric.redis).should_receive(:get).with('metric:tickets_count').once
+    value_metric.get
+  end
+
+  it "should set a value by delegating to redis" do
+    value_metric = Nightfury::Metric::Value.new(:tickets_count)
+    flexmock(value_metric.redis).should_receive(:set).with('metric:tickets_count', 1).once
+    value_metric.set(1)
+  end
+
+  it "should increment a value by delegating to redis" do
+    value_metric = Nightfury::Metric::Value.new(:tickets_count)
+    flexmock(value_metric.redis).should_receive(:incrby).with('metric:tickets_count', 1).once
+    value_metric.incr
+  end
+
+  it "should decrement a value by delegating to redis" do
+    value_metric = Nightfury::Metric::Value.new(:tickets_count)
+    flexmock(value_metric.redis).should_receive(:decrby).with('metric:tickets_count', 2).once
+    value_metric.decr(2)
+  end
+end

data/spec/nightfury/metric_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Nightfury::Metric::Base do
+  it "should have a name" do
+    metric = Nightfury::Metric::Base.new(:tickets_count)
+    metric.name.should == :tickets_count
+  end
+
+  it "should have a redis key" do
+    metric = Nightfury::Metric::Base.new(:tickets_count)
+    metric.redis_key.should == "metric:tickets_count"
+  end
+
+  it "should accept a redis key prefix" do
+    metric = Nightfury::Metric::Base.new(:tickets_count, redis_key_prefix: 'prefix')
+    metric.redis_key.should == "prefix:metric:tickets_count"
+  end
+
+  it "should have nightfury's redis connection" do
+    metric = Nightfury::Metric::Base.new(:tickets_count)
+    metric.redis.should == Nightfury.redis
+  end
+
+  it "should be able to remove itself" do
+    metric = Nightfury::Metric::Base.new(:tickets_count)
+    flexmock(metric.redis).should_receive(:del).with('metric:tickets_count').once
+    metric.delete
+  end
+end

data/spec/nightfury_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Nightfury do
+  describe "redis setup" do
+    it "should default redis connection to Redis.current" do
+      Nightfury.redis.client.host.should == "localhost"
+      Nightfury.redis.client.port.should == 9212
+      Nightfury.redis.client.db.should == 0
+    end
+
+    it "should accept a redis connection" do
+      redis = Redis.new
+      Nightfury.redis = redis
+      
+      Nightfury.redis.client.host.should == "127.0.0.1"
+      Nightfury.redis.client.port.should == 6379
+      Nightfury.redis.client.db.should == 0
+    end
+
+    it "should default redis namespace to 'nf'" do
+      Nightfury.redis.namespace.should == :nf
+    end
+
+    it "should set redis namespace to the specified namespace" do
+      Nightfury.namespace = :new_nf
+      Nightfury.redis.namespace.should == :new_nf
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'nightfury'
+require 'timecop'
+
+# Start our own redis-server to avoid corrupting any others
+REDIS_BIN  = 'redis-server'
+REDIS_PORT = ENV['REDIS_PORT'] || 9212
+REDIS_HOST = ENV['REDIS_HOST'] || 'localhost'
+REDIS_PID  = File.expand_path 'redis.pid', File.dirname(__FILE__)
+REDIS_DUMP = File.expand_path 'redis.rdb', File.dirname(__FILE__)
+puts "=> Starting redis-server on #{REDIS_HOST}:#{REDIS_PORT}"
+fork_pid = fork do
+  system "(echo port #{REDIS_PORT}; echo logfile /dev/null; echo daemonize yes; echo pidfile #{REDIS_PID}; echo dbfilename #{REDIS_DUMP}) | #{REDIS_BIN} -"
+end
+at_exit do
+  pid = File.read(REDIS_PID).to_i
+  puts "=> Killing #{REDIS_BIN} with pid #{pid}"
+  Process.kill "TERM", pid
+  Process.kill "KILL", pid
+  File.unlink REDIS_PID
+  File.unlink REDIS_DUMP if File.exists? REDIS_DUMP
+end
+
+REDIS_CLIENT = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+Redis.current = REDIS_CLIENT
+
+RSpec.configure do |config|
+  config.mock_with :flexmock
+
+  config.before(:each) do
+    REDIS_CLIENT.flushdb
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: nightfury
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Avinasha Shastry
+- Prateek Dayal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-17 00:00:00.000000000 Z
+dependencies: []
+description: Nightfury is a reporting/analytics backend written on Redis
+email:
+- me@avinasha.com
+- prateek@supportbee.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- example.rb
+- lib/nightfury.rb
+- lib/nightfury/identity.rb
+- lib/nightfury/metric.rb
+- lib/nightfury/metric/time_series.rb
+- lib/nightfury/metric/value.rb
+- lib/nightfury/version.rb
+- nightfury.gemspec
+- spec/nightfury/identity_spec.rb
+- spec/nightfury/metric/time_series_spec.rb
+- spec/nightfury/metric/value_spec.rb
+- spec/nightfury/metric_spec.rb
+- spec/nightfury_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- redis, v3.0.0 or greater
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Nightfury is a reporting/analytics backend written on Redis
+test_files:
+- spec/nightfury/identity_spec.rb
+- spec/nightfury/metric/time_series_spec.rb
+- spec/nightfury/metric/value_spec.rb
+- spec/nightfury/metric_spec.rb
+- spec/nightfury_spec.rb
+- spec/spec_helper.rb