turnstile-rb 2.0.1 → 3.0.2

data/lib/turnstile/collector/updater.rb

@@ -1,86 +0,0 @@
-module Turnstile
-  module Collector
-    class Updater
-
-      class Session < ::Struct.new(:uid, :platform, :ip); end
-
-      attr_accessor :queue, :semaphore, :cache, :tracker, :buffer_interval, :flush_interval
-
-      def initialize(queue, buffer_interval = 5, flush_interval = 6)
-        @queue = queue
-        @semaphore = Mutex.new
-        @cache = Hash.new(0)
-        @tracker = Turnstile::Tracker.new
-        @buffer_interval = buffer_interval
-        @buffer_interval = 6 if @buffer_interval <= 0
-        @flush_interval = flush_interval
-        @flush_interval = 5 if @flush_interval <= 0
-      end
-
-      def run
-        run_queue_popper
-        run_flusher
-      end
-
-      private
-
-      def run_flusher
-        Thread.new do
-          Thread.current[:name] = 'updater:flush'
-          loop do
-            semaphore.synchronize {
-              unless cache.empty?
-                Turnstile::Logger.logging "flushing cache with [#{cache.keys.size}] keys" do
-                  cache.keys.each do |key|
-                    session = parse(key)
-                    if session.uid && !session.uid.empty?
-                      tracker.track(session.uid, session.platform, session.ip)
-                    end
-                  end
-                  reset_cache
-                end
-              else
-                Turnstile::Logger.log "nothing to flush, sleeping #{flush_interval}s.."
-              end
-            }
-            sleep flush_interval
-          end
-        end
-      end
-
-      def run_queue_popper
-        Thread.new do
-          Thread.current[:name] = 'updater:queue'
-          loop do
-            unless queue.empty?
-              Turnstile::Logger.logging "caching [#{queue.size}] keys locally" do
-                while !queue.empty?
-                  semaphore.synchronize {
-                    add(queue.pop)
-                  }
-                end
-              end
-            else
-              Turnstile::Logger.log "nothing in the queue, sleeping #{buffer_interval}s..."
-            end
-            sleep buffer_interval
-          end
-        end
-      end
-
-      def add(token)
-        cache[token] = 1
-      end
-
-      def parse(token)
-        a = token.split(':')
-        Session.new(a[2], a[0], a[1])
-      end
-
-      def reset_cache
-        @cache.clear
-        GC.start
-      end
-    end
-  end
-end

data/lib/turnstile/parser.rb

@@ -1,107 +0,0 @@
-require 'optparse'
-require 'colored2'
-require 'forwardable'
-
-require 'turnstile/version'
-
-module Turnstile
-  class Parser
-    extend Forwardable
-    def_delegators :@system, :stdout, :stdin, :stderr
-
-    attr_accessor :options, :argv, :system
-
-    def initialize(argv, system)
-      self.system  = system
-      self.argv    = argv.dup
-      self.options = Hashie::Mash.new
-      self.argv << '-h' if argv.empty?
-    end
-
-    def parse
-      OptionParser.new do |opts|
-        opts.banner = "Usage:\n".bold.magenta +
-          "     turnstile -f <file> [ --daemon ]  [ options ]\n".yellow +
-          "     turnstile -s [ json | csv | nad ] [ options ]\n".yellow +
-          "     turnstile -a 'platform:ip:user'   [ options ]\n".yellow
-
-        opts.separator 'Description:'.bold.magenta
-        opts.separator '   ' + ::Turnstile::DESCRIPTION.gsub(/\n/, "\n   ")
-
-        opts.separator 'Log File Specification:'.bold.magenta
-        opts.on('-f', '--file FILE', 'File to monitor') do |file|
-          options[:file] = file
-        end
-        opts.on('-t', '--file-type TYPE',
-                'Either: json_formatted, pipe_delimited,',
-                'or comma_delimited (default).') do |type|
-          options[:filetype] = type
-        end
-        opts.on('-D', '--delimiter CHAR',
-                'Forces "delimited" file type, and uses ',
-                'the character in the argument as the delimiter') do |v|
-          options[:delimiter] = v
-        end
-        opts.separator "\nRedis Server:".bold.magenta
-        opts.on('-r', '--redis-url URL', 'Redis server URL') do |host|
-          Turnstile.config.redis_url = host
-        end
-        opts.on('--redis-host HOST', 'Redis server host') do |host|
-          Turnstile.config.redis_host = host
-        end
-        opts.on('--redis-port PORT', 'Redis server port') do |port|
-          Turnstile.config.redis_port = port
-        end
-        opts.on('--redis-db DB', 'Redis server db') do |db|
-          Turnstile.config.redis_db = db
-        end
-        opts.separator "\nMode of Operation:".bold.magenta
-        opts.on('-d', '--daemonize', 'Daemonize to watch the logs') do |v|
-          options[:daemonize] = true
-        end
-        opts.on('-s', '--summary [FORMAT]',
-                'Print current stats and exit. Optional format can be',
-                'json (default), nad, yaml, or csv') do |v|
-          options[:summary]        = true
-          options[:summary_format] = (v || 'json').to_sym
-        end
-        opts.on('-a', '--add TOKEN',
-                'Registers an event from the token, such as ',
-                '"ios:123.4.4.4:32442". Use -d to customize delimiter.') do |v|
-          options[:add] = v
-        end
-        opts.separator "\nTiming Adjustments:".bold.magenta
-        opts.on('-b', '--buffer-interval INTERVAL', 'Buffer for this many seconds') do |v|
-          options[:buffer_interval] = v.to_i
-        end
-        opts.on('-i', '--flush-interval INTERVAL', 'Flush then sleep for this many seconds') do |v|
-          options[:flush_interval] = v.to_i
-        end
-        opts.separator "\nMiscellaneous:".bold.magenta
-        opts.on('-v', '--verbose', 'Print status to stdout') do |v|
-          options[:debug] = true
-        end
-        opts.on_tail('-h', '--help', 'Show this message') do
-          puts opts
-          return
-        end
-      end.parse!(argv)
-
-      if options[:summary]
-        Turnstile::Summary.print(options[:summary_format] || :json, options[:delimiter])
-      elsif options[:add]
-        Turnstile::Tracker.new.add_token(options[:add], options[:delimiter] || ':')
-        Turnstile::Summary.print(options[:summary_format] || :json)
-      else
-        Turnstile::Collector::Runner.new(options).run
-      end
-
-    rescue OptionParser::MissingArgument => e
-      STDERR.puts e.message.bold.red
-    rescue Exception => e
-      STDERR.puts e.message.bold.red
-    end
-  end
-end
-
-

data/lib/turnstile/runner.rb

@@ -1,54 +0,0 @@
-require 'optparse'
-require 'colored2'
-
-require 'turnstile/version'
-require 'turnstile/parser'
-
-module Turnstile
-
-
-  class Runner
-    attr_reader :argv, :stdin, :stdout, :stderr, :kernel
-
-    # Allow everything fun to be injected from the outside while defaulting to normal implementations.
-    def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
-      @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
-    end
-
-    def execute!
-      exit_code = begin
-
-        Colored2.disable! unless stdout.tty?
-
-        $stderr = stderr
-        $stdin  = stdin
-        $stdout = stdout
-
-        Turnstile::Parser.new(argv, self).parse
-
-        # Thor::Base#start does not have a return value, assume success if no exception is raised.
-        0
-      rescue StandardError => e
-        # The ruby interpreter would pipe this to STDERR and exit 1 in the case of an unhandled exception
-        b = e.backtrace
-        @stderr.puts("#{b.shift}: #{e.message} (#{e.class})")
-        @stderr.puts(b.map { |s| "\tfrom #{s}" }.join("\n"))
-        1
-      rescue SystemExit => e
-        e.status
-      ensure
-        $stderr = STDERR
-        $stdin  = STDIN
-        $stdout = STDOUT
-      end
-
-      # Proxy our exit code back to the injected kernel.
-      @kernel.exit(exit_code)
-    end
-  end
-end
-
-module Turnstile
-
-end
-

data/lib/turnstile/summary.rb

@@ -1,57 +0,0 @@
-require 'csv'
-module Turnstile
-  class Summary
-
-    class << self
-      def print(method, delimiter = nil)
-        summary = new
-        if summary.respond_to?(method)
-          STDOUT.puts summary.send(method, delimiter)
-        else
-          STDERR.puts "don't know how to use format '#{method}'mac"
-        end
-      end
-    end
-
-    def json(*)
-      out = "{\n"
-      first = true
-      aggregate.each_pair do |key, value|
-        out << ",\n" unless first
-        first = false
-        out << json_row(key, value)
-      end
-      out << "\n}"
-      out
-    end
-
-    def nad(*)
-      out = ''
-      aggregate.each_pair do |key, value|
-        out << nad_row(key, value)
-      end
-      out
-    end
-
-    def csv(delimiter = nil)
-      out = CSV.generate do |csv|
-        aggregate.each_pair do |key, value|
-          csv << [key, value]
-        end
-      end
-      delimiter ? out.gsub(/,/m, delimiter) : out
-    end
-
-    def nad_row(key, value)
-      %Q(turnstile:#{key}#{"\tn\t"}#{value}\n)
-    end
-
-    def json_row(key, value)
-      %Q(  "#{key}": #{value})
-    end
-
-    def aggregate
-      Turnstile::Adapter.new.aggregate
-    end
-  end
-end

data/spec/turnstile/summary_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe Turnstile::Summary do
-  subject { described_class.new }
-
-  let(:aggregate) {
-    {
-      'android' => 3,
-      'ios'     => 2,
-      'total'   => 5
-    }
-  }
-
-  before { expect(subject).to receive(:aggregate).once.and_return(aggregate) }
-
-  describe '#nad' do
-    context 'have some data' do
-      let(:expected_string) {
-        <<-EOF
-turnstile:android#{"\t"}n#{"\t"}3
-turnstile:ios#{"\t"}n#{"\t"}2
-turnstile:total#{"\t"}n#{"\t"}5
-        EOF
-      }
-
-      it 'return data in NAD format' do
-        expect(subject.nad).to eql(expected_string)
-      end
-    end
-  end
-
-  describe '#json' do
-    context 'have some data' do
-      let(:json) { subject.json }
-      let(:hash) { JSON.load(json) }
-      it 'return data in NAD format' do
-        expect(hash).to eql(aggregate)
-      end
-    end
-  end
-end