turnstile-rb 2.0.1 → 3.0.2

data/lib/turnstile/configuration.rb

@@ -1,5 +1,6 @@
 require 'hashie/dash'
 require 'hashie/extensions/dash/property_translation'
+require 'pp'
 
 module Turnstile
   class RedisConfig < ::Hashie::Dash
@@ -10,6 +11,9 @@ module Turnstile
     property :port, default: 6379, required: true, transform_with: ->(value) { value.to_i }
     property :db, default: 1, required: true, transform_with: ->(value) { value.to_i }
     property :timeout, default: 0.05, required: true, transform_with: ->(value) { value.to_f }
+    property :namespace, default: '', required: false
+    property :pool_size, default: 5, required: true
+    property :use_hiredis, default: false
 
     def configure
       yield self if block_given?
@@ -22,12 +26,31 @@ module Turnstile
     property :activity_interval, default: 60, required: true, transform_with: ->(value) { value.to_i }
     property :sampling_rate, default: 100, required: true, transform_with: ->(value) { value.to_i }
     property :redis, default: ::Turnstile::RedisConfig.new
+    property :custom_matcher
+    property :flush_interval, default: 10
+    property :trace
+    property :port, default: ::Turnstile::DEFAULT_PORT
 
     def configure
       yield self if block_given?
       self
     end
 
+    class << self
+      def from_file(file = nil)
+        return unless file
+        require(normalize(file))
+      rescue Exception => e
+        raise ConfigFileError.new("Error reading configuration from a file #{file}: #{e.message}")
+      end
+
+      private
+
+      def normalize(file)
+        file.start_with?('/') ? file : Dir.pwd + '/' + file
+      end
+    end
+
     def method_missing(method, *args, &block)
       return super unless method.to_s =~ /^redis_/
       prop = method.to_s.gsub(/^redis_/, '').to_sym

data/lib/turnstile/dependencies.rb

@@ -0,0 +1,31 @@
+require_relative 'logger/helper'
+module Turnstile
+  module Dependencies
+    def self.included(base)
+      base.include(Turnstile::Logger::Helper)
+      base.class_eval do
+
+        def tracker
+          @tracker ||= Tracker.new
+        end
+
+        def adapter
+          @adapter ||= Redis::Adapter.instance
+        end
+
+        def sampler
+          @sampler ||= Sampler.new
+        end
+
+        def config
+          @config ||= Turnstile.config
+        end
+
+        def aggregate
+          adapter.aggregate
+        end
+
+      end
+    end
+  end
+end

data/lib/turnstile/logger.rb

@@ -1,47 +1,16 @@
+require 'logger'
+require_relative 'logger/helper'
+require_relative 'logger/provider'
+
 module Turnstile
   module Logger
+    STDOUT.sync   = true
+    @logger       = ::Logger.new(STDOUT)
+    @logger.level = ::Logger::INFO
+    @enabled      = false
 
     class << self
-      def enable
-        class << self
-          self.send(:define_method, :log, proc { |msg| _log(msg) })
-          self.send(:define_method, :logging, proc { |msg, &block| _logging(msg, &block) })
-        end
-      end
-
-      def disable
-        class << self
-          self.send(:define_method, :log, proc { |msg|})
-          self.send(:define_method, :logging, proc { |msg, &block| block.call })
-        end
-      end
-
-      def log(msg)
-      end
-
-      def logging(msg, &block)
-        block.call
-      end
-
-      private
-
-      def _log(msg)
-        puts "#{Time.now}: #{sprintf("%-20s", Thread.current[:name])} - #{msg}"
-      end
-
-      def _logging(message, &block)
-        start = Time.now
-        returned_from_block = yield
-        elapsed_time = Time.now - start
-        if returned_from_block.is_a?(String) && returned_from_block != ""
-          message += " - #{returned_from_block}"
-        end
-        log "(#{"%9.2f" % (1000 * elapsed_time)}ms) #{message}"
-        returned_from_block
-      rescue Exception => e
-        elapsed_time = Time.now - start
-        log "(#{"%9.2f" % (1000 * elapsed_time)}ms) error: #{e.message} for #{message} "
-      end
+      include Provider
     end
   end
 end

data/lib/turnstile/logger/helper.rb

@@ -0,0 +1,42 @@
+module Turnstile
+  module Logger
+    module Helper
+      def self.included(base)
+        base.extend(Helper)
+      end
+
+      def debug(*args, &block)
+        Turnstile::Logger.log(:debug, *args, &block)
+      end
+
+      def info(*args, &block)
+        Turnstile::Logger.log(:info, *args, &block)
+      end
+
+      def warn(*args, &block)
+        Turnstile::Logger.log(:warn, *args, &block)
+      end
+
+      def error(*args, &block)
+        Turnstile::Logger.log(:error, *args, &block)
+      end
+
+      def with_duration(level = :info, *args, &block)
+        Turnstile::Logger.logging(level, *args, &block)
+      end
+
+      def info_elapsed(*args, &block)
+        with_duration(:info, *args, &block)
+      end
+
+      def error_elapsed(*args, &block)
+        with_duration(:error, *args, &block)
+      end
+
+      alias with_logging info_elapsed
+      alias around_logging info_elapsed
+      alias log_around info_elapsed
+
+    end
+  end
+end

data/lib/turnstile/logger/provider.rb

@@ -0,0 +1,74 @@
+require_relative 'helper'
+
+module Turnstile
+  module Logger
+    module Provider
+      attr_accessor :logger, :enabled
+
+      include Helper
+
+
+      def enable
+        self.enabled = true
+        class << self
+          self.send(:define_method, :log, proc { |level = :info, msg| _log(level, msg) })
+          self.send(:define_method, :logging, proc { |level = :info, msg, &block| _logging(level, msg, &block) })
+        end
+      end
+
+
+      def disable
+        self.enabled = false
+        class << self
+          self.send(:define_method, :log, proc { |_| })
+          self.send(:define_method, :logging, proc { |_, &block| block.call })
+        end
+      end
+
+
+      def log(*)
+        # no op
+      end
+
+
+      def logging(*)
+        # No op
+      end
+
+
+      private
+
+      def _log(level = :info, msg)
+        logger.send(level) do
+          "#{sprintf('%-15s', Thread.current[:name] || 'thread-main')} | #{msg}"
+        end
+      end
+
+
+      def _logging(level = :info, *args, &_block)
+        message = args.join(' ')
+
+        log(level, message) unless block_given?
+        return unless block_given?
+
+        start = Time.now
+        yield.tap do |result|
+          elapsed_time = Time.now - start
+          if result
+            message += " #{result.to_s}"
+          end
+          log_elapsed(level, elapsed_time, message)
+        end
+      rescue Exception => e
+        elapsed_time = Time.now - start
+        log_elapsed(level, elapsed_time, "error: #{e.message} for #{message}")
+      end
+
+
+      def log_elapsed(level = :info, elapsed_time, message)
+        log(level, "(#{'%7.2f' % (1000 * elapsed_time)}ms) #{message}")
+      end
+
+    end
+  end
+end

data/lib/turnstile/observer.rb

@@ -1,5 +1,8 @@
 require 'hashie/mash'
 require 'hashie/extensions/mash/symbolize_keys'
+require_relative 'redis/adapter'
+
+require_relative 'dependencies'
 
 module Turnstile
   class Stats < ::Hashie::Mash
@@ -7,6 +10,8 @@ module Turnstile
   end
 
   class Observer
+    include Dependencies
+
     def stats
       data      = adapter.fetch
       platforms = Hash[data.group_by { |d| d[:platform] }.map { |k, v| [k, sampler.extrapolate(v.count)] }]
@@ -20,14 +25,5 @@ module Turnstile
                 })
     end
 
-    private
-
-    def adapter
-      @adapter ||= Adapter.new
-    end
-
-    def sampler
-      @sampler ||= Sampler.new
-    end
   end
 end

data/lib/turnstile/redis/adapter.rb

@@ -0,0 +1,97 @@
+require 'redis'
+require 'timeout'
+require 'singleton'
+require 'connection_pool'
+require_relative '../logger/helper'
+require_relative 'connection'
+
+module Turnstile
+  module Redis
+    class Adapter
+      SEP = ':'
+
+      include Singleton
+      include Logger::Helper
+      include Connection
+
+      attr_accessor :connection_pool, :config
+
+      # noinspection RubyResolve
+      def add(uid, platform, ip)
+        key = compose_key(uid, platform, ip)
+        timeout(config.redis.timeout) do
+          with_redis do |redis|
+            redis.setex(key, config.activity_interval, 1)
+          end
+        end
+      rescue StandardError => e
+        error "exception while writing to redis: #{e.inspect}"
+      end
+
+      def fetch
+        all_keys.map do |key|
+          fields = key.split(SEP)
+          {
+            uid:      fields[1],
+            platform: fields[2],
+            ip:       fields[3],
+          }
+        end
+      end
+
+      def all_keys
+        with_redis do |redis|
+          redis.keys("#{prefix}*")
+        end
+      end
+
+      def aggregate
+        all_keys.inject({}) { |hash, key| increment_platform(hash, key) }.tap do |h|
+          h['total'] = h.values.inject(&:+) || 0
+        end
+      end
+
+      def increment_platform(hash, key)
+        tuple = key.flatten if key.is_a?(Array)
+        tuple = key.split(SEP) if key.is_a?(String)
+
+        platform = tuple[2]
+
+        raise ArgumentError, "can't determine platform from the key #{key.inspect}" unless platform
+
+        hash[platform] ||= 0
+        hash[platform] += 1
+        hash
+      end
+
+      def config
+        Turnstile.config
+      end
+
+      def rconfig
+        config.redis
+      end
+
+      def compose_key(uid, platform = nil, ip = nil)
+        "#{prefix}#{uid}#{SEP}#{platform}#{SEP}#{ip}"
+      end
+
+      # def redis
+      #   @redis ||= ConnectionPool::Wrapper.new(size: 3, timeout: 15, &redis_factory)
+      # end
+
+
+      private
+
+      def initialize(config = Turnstile.config)
+        self.config = config
+        self.connection_pool
+      end
+
+      def prefix
+        @prefix ||= "#{Turnstile::NS}|#{config.redis.namespace.gsub(/#{SEP}/, ':')}#{SEP}"
+      end
+    end
+  end
+end
+

data/lib/turnstile/redis/connection.rb

@@ -0,0 +1,116 @@
+require 'timeout'
+require 'colored2'
+require_relative 'adapter'
+
+module Turnstile
+  module Redis
+    module Connection
+      include Timeout
+
+      attr_accessor :config
+
+      def exec(redis_method, *args, &block)
+        send_proc = redis_method if redis_method.respond_to?(:call)
+        send_proc ||= ->(redis) { redis.send(redis_method, *args, &block) }
+        with_redis { |redis| send_proc.call(redis) }
+      end
+
+      %i(set get incr decr setex expire del setnx exists zadd zrange flushdb).each do |method|
+        define_method(method) do |*args|
+          self.exec method, *args
+        end
+      end
+
+      def with_redis
+        with_retries do
+          pool.with do |redis|
+            yield(Turnstile.debug? ? LoggingRedis.new(redis) : redis)
+          end
+        end
+      end
+
+      def with_pipelined
+        with_retries do
+          with_redis do |redis|
+            redis.pipelined do
+              yield(redis)
+            end
+          end
+        end
+      end
+
+      def with_multi
+        with_retries do
+          with_redis do |redis|
+            redis.multi do
+              yield(redis)
+            end
+          end
+        end
+      end
+
+      def with_retries(tries = 3)
+        yield(tries)
+      rescue Errno::EINVAL => e
+        on_error e
+      rescue ::Redis::BaseConnectionError => e
+        if (tries -= 1) > 0
+          sleep rand(0..0.01)
+          retry
+        else
+          on_error e
+        end
+      rescue ::Redis::CommandError => e
+        (e.message =~ /loading/i || e.message =~ /connection/i) ? on_error(e) : raise(e)
+      end
+
+      # This is how we'll be creating redis; depending on input arguments:
+      def redis_proc
+        @redis_proc ||= (config.redis.url ? redis_proc_from_url : redis_proc_from_opts)
+      end
+
+      # Connection pool to the Redis server
+      def pool
+        @pool ||= ::ConnectionPool.new(size: config.redis.pool_size, &redis_proc)
+      end
+
+      def on_error(e)
+        raise Error.new(e)
+      end
+
+      def redis_proc_from_url
+        @redis_proc_from_url ||= proc do
+          ::Redis.new(redis_opts(url: config.redis.url)).tap do |conn|
+            log_connection(conn)
+          end
+        end
+      end
+
+      def redis_opts(opts)
+        opts.tap do |hash|
+          hash[:driver] = 'hiredis' if config.redis_use_hiredis
+        end
+      end
+
+      def redis_proc_from_opts
+        @redis_proc_from_opts ||= proc {
+          ::Redis.new(redis_opts(host: config.redis.host,
+                                 port: config.redis.port,
+                                 db:   config.redis.db)).tap do |conn|
+            log_connection(conn)
+          end
+        }
+      end
+
+      private
+
+      def log_connection(conn)
+        if config.trace
+          tdb "created a new redis connection: #{conn}"
+          tdb "driver: #{conn.instance_variable_get(:@client).driver}"
+        end
+      end
+    end
+  end
+end
+