ocular 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9744f295fb350d3864ab65a80a3506281f776f3
-  data.tar.gz: 453713667fc0c6c7eec8b359dbab2b49d4523b25
+  metadata.gz: 3121ebd021fce075c9b4232f8980fa3bec3bde96
+  data.tar.gz: ecaf0bb7bbf9ae725f1f29ea179c786a3a3d40b8
 SHA512:
-  metadata.gz: c4efd125317945bc07ae03513116e087884895988bfa2d2d92f61326aa9da7d2d9f1d0418b18f005c6c25f5e779c0bd6ebda18c0281b86c5e9ea8a17518bfcbe
-  data.tar.gz: 456e9158a506e24382c8a1fa03c6d17ab87ea2fa2b0a8afe11689c7170ab9b267724dff8a1b823506d89d08f3d6c9b6a0c10b07b4e601aa3dd8a0d453ea91210
+  metadata.gz: afdd0c1d5d190f029099fe21572c2bbd9d755c908b64f8d704955c2b2544ffcfb41fc885f4bfa7aade66350398907a172d134ee1ccbce78695d1bebd1f472ad3
+  data.tar.gz: 5b826d61d4609aa6e26b6d56eed01db1c64c38898ce72ce3ff87ca9f5b625f51cf1f1a998ea70fe2904d64eeb1061134d0ee6ac048d13d1b08e16a4c46af850c

data/bin/ocular

@@ -23,6 +23,7 @@ class OptparseExample
     options.server = false
     options.settings = nil
     options.root = nil
+    options.check = nil
 
     opt_parser = OptionParser.new do |opts|
       opts.banner = "Usage in shell mode: \"ocular [options] <script file>\" or server mode: \"ocular --server [options]\""
@@ -59,6 +60,10 @@ class OptparseExample
         options.settings = path
       end
 
+      opts.on("--check", "Do only syntax check") do
+        options.check = true
+      end
+
     end
 
     opt_parser.parse!(args)
@@ -95,7 +100,24 @@ inputs:
   exit -1
 end
 
-if options.server
+logger = Ocular::Logging::MultiLogger.new
+
+if Ocular::Settings.get(:loggers)
+  Ocular::Settings.get(:loggers).each do |name, settings|
+    name = name.to_s
+    if name == "console"
+      logger.add_logger(Ocular::Logging::ConsoleLogger.new(settings))
+    elsif name == "kafka"
+      logger.add_logger(Ocular::Logging::KafkaLogger.new(settings))
+    else
+      puts "Unknown logging engine #{name}"
+    end
+  end
+else 
+  logger.add_logger(Ocular::Logging::ConsoleLogger.new)
+end
+
+if options.server or options.syntax
   if !options.root && !Ocular::Settings.get(:script_root)
     puts "Please specify --root or set script_root in the settings.yaml"
     exit
@@ -103,6 +125,11 @@ if options.server
 
   daemon = Ocular::Daemon.new(options.root || Ocular::Settings.get(:script_root))
   daemon.load_script_files()
+
+  if options.syntax
+    exit 0
+  end
+
   daemon.start_input_handlers()
 
   puts "server started"
@@ -151,7 +178,7 @@ else
 
       ef = Ocular::Event::EventFactory.new
 
-      context = Ocular::DSL::REPLRunContext.new(ef.handlers)
+      context = Ocular::DSL::REPLRunContext.new(ef.handlers, logger)
 
       irb = IRB::Irb.new(IRB::WorkSpace.new(context))
       IRB.conf[:MAIN_CONTEXT] = irb.context
@@ -174,7 +201,7 @@ else
   ef = Ocular::Event::EventFactory.new
   proxy = ef.load_from_file(ARGV.shift)
 
-  context = Ocular::DSL::RunContext.new
+  context = Ocular::DSL::RunContext.new(logger)
   eventbase = proxy.events["onEvent"]["cli"]
   eventbase.exec(context)
 

data/lib/ocular/dsl/fog.rb

@@ -44,6 +44,18 @@ class Ocular
                 return instances
             end
 
+            add_help "find_server_by_ip", "Returns Fog::Compute::AWS::Server or nil"
+            def find_server_by_ip(ip)
+                ret = aws().servers.all("private-ip-address" => ip)
+                if ret.length > 1
+                    raise "Too many matching servers by just one ip #{ip}"
+                end
+                if ret.length == 0
+                    return nil
+                end
+                return ret.first
+            end
+
         end
 
     end

data/lib/ocular/dsl/logging.rb

@@ -5,112 +5,39 @@ class Ocular
         module Logging
 
             def debug(message = nil, &block)
-                @logger.add(Logger::Severity::DEBUG, message, @run_id, &block)
+                @logger.add(::Ocular::Logging::Severity::DEBUG, message, @run_id, &block)
             end
             alias log debug
 
             def info(message = nil, &block)
-                @logger.add(Logger::Severity::INFO, message, @run_id, &block)
+                @logger.add(::Ocular::Logging::Severity::INFO, message, @run_id, &block)
             end
 
             def warn(message = nil, &block)
-                @logger.add(Logger::Severity::WARN, message, @run_id, &block)
+                @logger.add(::Ocular::Logging::Severity::WARN, message, @run_id, &block)
             end
 
             def error(message = nil, &block)
-                @logger.add(Logger::Severity::ERROR, message, @run_id, &block)
+                @logger.add(::Ocular::Logging::Severity::ERROR, message, @run_id, &block)
             end
 
             def fatal(message = nil, &block)
-                @logger.add(Logger::Severity::FATAL, message, @run_id, &block)
+                @logger.add(::Ocular::Logging::Severity::FATAL, message, @run_id, &block)
             end
 
-
-        end
-
-        # Most of the Logger class is copied from the Ruby Logger class source code.
-        class Logger
-
-            # Logging severity.
-            module Severity
-                # Low-level information, mostly for developers.
-                DEBUG = 0
-                # Generic (useful) information about system operation.
-                INFO = 1
-                # A warning.
-                WARN = 2
-                # A handleable error condition.
-                ERROR = 3
-                # An unhandleable error that results in a program crash.
-                FATAL = 4
-                # An unknown message that should always be logged.
-                UNKNOWN = 5
+            def log_event(property, value)
+                @logger.log_event(property, value, @run_id)
             end
 
-            def initialize()
-                @level = Severity::DEBUG
-                @formatter = Logger::Formatter.new
-            end            
-
-            def add(severity, message = nil, run_id = nil, &block)
-                severity ||= Severity::UNKNOWN
-                if severity < @level
-                    return true
-                end
-
-                if message.nil?
-                    if block_given?
-                        message = yield
-                    else
-                        message = progname
-                    end
-                end
-    
-                puts format_message(format_severity(severity), Time.now, run_id, message)
-                true
+            def log_cause(type, environment)
+                @logger.log_cause(type, environment, @run_id)
             end
 
-            SEV_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY).each(&:freeze).freeze
-
-            def format_severity(severity)
-                SEV_LABEL[severity] || 'ANY'
-            end            
-
-            def format_message(severity, datetime, progname, msg)
-                @formatter.call(severity, datetime, progname, msg)
-            end
-
-            # Default formatter for log messages.
-            class Formatter
-                Format = "%s, [%s#%d] %5s -- %s: %s\n".freeze
-
-                attr_accessor :datetime_format
-
-                def initialize
-                    @datetime_format = nil
-                end
-
-                def call(severity, time, progname, msg)
-                    Format % [severity[0..0], format_datetime(time), $$, severity, progname, msg2str(msg)]
-                end
-
-            private
-
-                def format_datetime(time)
-                    time.strftime(@datetime_format || "%Y-%m-%dT%H:%M:%S.%6N ".freeze)
-                end
-
-                def msg2str(msg)
-                    case msg
-                    when ::String
-                        msg
-                    when ::Exception
-                        "#{ msg.message } (#{ msg.class })\n" <<
-                        (msg.backtrace || []).join("\n")
-                    else
-                        msg.inspect
-                    end
+            def log_timing(name, value)
+                if value.is_a? Time
+                    value = (Time.now - value) * 1000 # report in milliseconds
                 end
+                @logger.log_timing(name, value, @run_id)
             end
         end
     end

data/lib/ocular/dsl/runcontext.rb

@@ -18,9 +18,9 @@ class Ocular
 
             include Ocular::Inputs::Cron::DSL
 
-            def initialize
+            def initialize(logger)
                 @run_id = SecureRandom.uuid()
-                @logger = Ocular::DSL::Logger.new
+                @logger = logger
                 @cleanups = []
             end
 
@@ -47,9 +47,10 @@ class Ocular
             attr_reader :handlers
             attr_reader :events
             attr_reader :do_fork
+            attr_reader :logger
 
-            def initialize(handlers)
-                super()
+            def initialize(handlers, logger)
+                super(logger)
                 @events = {}
                 @handlers = handlers
                 @do_fork = false

data/lib/ocular/event/eventbase.rb

@@ -1,5 +1,6 @@
 require 'ocular/mixin/from_file'
 require 'ocular/dsl/logging'
+require 'time'
 
 class Ocular
     module DSL
@@ -13,16 +14,22 @@ class Ocular
 
             attr_accessor :proxy
 
-            def initialize(&block)
+            def initialize(proxy, &block)
                 @callback = block
+                @proxy = proxy
             end
 
             def exec(context, do_fork = self.proxy.do_fork)
-                context.proxy = self.proxy
-                if do_fork
-                    return exec_fork(context)
-                else
-                    return exec_nofork(context)
+                start = Time.now
+                begin
+                    context.proxy = self.proxy
+                    if do_fork
+                        return exec_fork(context)
+                    else
+                        return exec_nofork(context)
+                    end
+                ensure
+                    context.log_timing("execution_time", start)
                 end
             end
 

data/lib/ocular/event/eventfactory.rb

@@ -2,18 +2,19 @@ require 'ocular/inputs/handlers.rb'
 require 'ocular/event/eventbase.rb'
 require 'ocular/inputs/http_input.rb'
 require 'ocular/inputs/cron_input.rb'
+require 'ocular/inputs/trigger_input.rb'
 
 class Ocular
     module Event
         class DefinitionProxy
             attr_accessor :events
-            attr_reader :script_name, :do_fork
+            attr_reader :script_name, :do_fork, :logger
             attr_accessor :handlers, :events
 
             def initialize(script_name, handlers)
                 @script_name = script_name
                 @events = {}
-                @logger = Ocular::DSL::Logger.new
+                @logger = Ocular::Logging::ConsoleLogger.new
                 @handlers = handlers
                 @do_fork = true
             end
@@ -26,14 +27,14 @@ class Ocular
 
             include Ocular::Inputs::HTTP::DSL
             include Ocular::Inputs::Cron::DSL
+            include Ocular::Inputs::Trigger::DSL
 
             def fork(value)
                 @do_fork = value
             end
 
             def onEvent(type, &block)
-                eventbase = Ocular::DSL::EventBase.new(&block)
-                eventbase.proxy = self
+                eventbase = Ocular::DSL::EventBase.new(self, &block)
                 (@events["onEvent"] ||= {})[type] = eventbase
             end
         end

data/lib/ocular/inputs/cron_input.rb

@@ -17,7 +17,7 @@ class Ocular
                 add_event_help "cron.cron(rule)", "Schedule event with cron syntax. eg: '5 0 * * *'"
                 def cron()
                     handler = handlers.get(::Ocular::Inputs::Cron::Input)
-                    return Input::DSLProxy.new(self, handler)
+                    return Input::DSLProxy.new(self, handler, logger)
                 end
 
             end
@@ -43,17 +43,18 @@ class Ocular
                 end
 
                 class DSLProxy
-                    def initialize(proxy, handler)
+                    def initialize(proxy, handler, logger)
                         @proxy = proxy
                         @handler = handler
+                        @logger = logger
                     end
 
                     def in(rule, &block)
-                        eventbase = Ocular::DSL::EventBase.new(&block)
-                        eventbase.proxy = @proxy
+                        eventbase = Ocular::DSL::EventBase.new(@proxy, &block)
 
                         id = @handler.scheduler.in(rule) do
-                            context = ::Ocular::DSL::RunContext.new
+                            context = ::Ocular::DSL::RunContext.new(@logger)
+                            context.log_cause("cron.in", {:rule => rule})
                             eventbase.exec(context)
                         end
 
@@ -63,11 +64,11 @@ class Ocular
                     end
 
                     def at(rule, &block)
-                        eventbase = Ocular::DSL::EventBase.new(&block)
-                        eventbase.proxy = @proxy
+                        eventbase = Ocular::DSL::EventBase.new(@proxy, &block)
 
                         id = @handler.scheduler.at(rule) do
-                            context = ::Ocular::DSL::RunContext.new
+                            context = ::Ocular::DSL::RunContext.new(@logger)
+                            context.log_cause("cron.at", {:rule => rule})
                             eventbase.exec(context)
                         end
 
@@ -77,11 +78,11 @@ class Ocular
                     end
 
                     def every(rule, &block)
-                        eventbase = Ocular::DSL::EventBase.new(&block)
-                        eventbase.proxy = @proxy
+                        eventbase = Ocular::DSL::EventBase.new(@proxy, &block)
 
                         id = @handler.scheduler.every(rule) do
-                            context = ::Ocular::DSL::RunContext.new
+                            context = ::Ocular::DSL::RunContext.new(@logger)
+                            context.log_cause("cron.every", {:rule => rule})
                             eventbase.exec(context)
                         end
 
@@ -91,11 +92,11 @@ class Ocular
                     end
 
                     def cron(rule, &block)
-                        eventbase = Ocular::DSL::EventBase.new(&block)
-                        eventbase.proxy = @proxy
+                        eventbase = Ocular::DSL::EventBase.new(@proxy, &block)
 
                         id = @handler.scheduler.cron(rule) do
-                            context = ::Ocular::DSL::RunContext.new
+                            context = ::Ocular::DSL::RunContext.new(@logger)
+                            context.log_cause("cron.cron", {:rule => rule})
                             eventbase.exec(context)
                         end
 

data/lib/ocular/inputs/http_input.rb

@@ -43,7 +43,7 @@ class Ocular
                     attr_accessor :request, :response, :params, :env
 
                     def initialize()
-                        super()
+                        super(Ocular::Logging::ConsoleLogger.new) 
                         @headers = {}
                     end
 
@@ -268,15 +268,25 @@ class Ocular
                 end
 
                 def route(verb, path, options, proxy, &block)
-                    eventbase = Ocular::DSL::EventBase.new(&block)
-                    eventbase.proxy = proxy
+                    eventbase = Ocular::DSL::EventBase.new(proxy, &block)
                     (proxy.events[verb] ||= {})[path] = eventbase
 
                     pattern, keys = compile(path)
 
                     (@routes[verb] ||= []) << build_signature(pattern, keys) do |context|
-                        context.event_signature = [verb, path] 
-                        eventbase.exec(context)
+                        context.event_signature = [verb, path]
+                        response = eventbase.exec(context)
+                        environment = {
+                            :path => path,
+                            :options => options,
+                            :request => context.request,
+                            :params => context.params,
+                            :env => context.env,
+                            :response => response
+                        }
+                        context.log_cause("on#{verb}", environment)
+
+                        response
                     end
                 end
 

data/lib/ocular/inputs/trigger_input.rb

@@ -0,0 +1,55 @@
+
+require 'ocular/inputs/base.rb'
+require 'ocular/dsl/dsl.rb'
+require 'ocular/dsl/runcontext.rb'
+require 'rufus/scheduler'
+
+class Ocular
+    module Inputs
+
+        module Trigger
+
+            module DSL
+
+                def onTrigger(evaluator, &block)
+                    handler = handlers.get(::Ocular::Inputs::Trigger::Input)
+
+                    eventbase = Ocular::DSL::EventBase.new(@proxy, &block)
+
+                    id = handler.add_evaluator(evaluator) do
+                        context = ::Ocular::DSL::RunContext.new(@logger)
+                        eventbase.exec(context)
+                    end
+
+                    @proxy.events[id] = eventbase
+
+                    return id
+                end
+
+            end
+
+            class Input < ::Ocular::Inputs::Base
+
+                attr_reader :routes
+                attr_reader :scheduler
+
+                def initialize(settings_factory)
+                    settings = settings_factory[:http]
+                    @scheduler = ::Rufus::Scheduler.new
+                end
+
+                def start()
+
+                end
+
+                def add_evaluator(evaluator, &block)
+
+                end
+
+                def stop()
+                    @scheduler.shutdown
+                end
+            end
+        end
+    end
+end

data/lib/ocular/logging/console_logger.rb

@@ -0,0 +1,97 @@
+
+class Ocular
+    module Logging
+
+        # Most of the Logger class is copied from the Ruby Logger class source code.
+        class ConsoleLogger
+
+            def initialize(settings=nil)
+                @level = Severity::INFO
+                @formatter = Formatter.new
+            end            
+
+            def add(severity, message = nil, run_id = nil, &block)
+                severity ||= Severity::UNKNOWN
+                if severity < @level
+                    return true
+                end
+
+                if message.nil?
+                    if block_given?
+                        message = yield
+                    else
+                        message = progname
+                    end
+                end
+    
+                puts @formatter.format_message(severity, Time.now, message)
+                true
+            end
+
+            def log_event(property, value, run_id = nil)
+                puts @formatter.format_event(property, value, Time.now)
+                true
+            end            
+
+            def log_cause(type, environment, run_id = nil)
+                if @level == Severity::DEBUG
+                    puts @formatter.format_cause(type, environment, Time.now)
+                end
+                true
+            end
+
+            def log_timing(key, value, run_id = nil)
+                puts @formatter.format_timing(key, value, Time.now)
+                true
+            end            
+
+            # Default formatter for log messages.
+            class Formatter
+                Format = "[%s#%d] %s -- %s\n".freeze
+                EventFormat = "[%s#%d] -- %s: %s\n".freeze
+                CauseFormat = "[%s#%d] -- %s triggered processing with environment: %s\n".freeze
+                TimingFormat = "[%s#%d] -- %s took %s ms\n".freeze
+
+                attr_accessor :datetime_format
+
+                def initialize
+                    @datetime_format = nil
+                end
+
+                def format_message(severity, time, msg)
+                    Format % [format_datetime(time), $$, Ocular::Logging::Severity::LABELS[severity], msg2str(msg)]
+                end
+
+                def format_event(property, value, time)
+                    EventFormat % [format_datetime(time), $$, property, value]
+                end
+
+                def format_cause(type, environment, time)
+                    CauseFormat % [format_datetime(time), $$, type, environment.to_json]
+                end
+
+                def format_timing(key, value, time)
+                    TimingFormat % [format_datetime(time), $$, key, value]
+                end                
+
+            private
+
+                def format_datetime(time)
+                    time.strftime(@datetime_format || "%Y-%m-%dT%H:%M:%S.%6N ".freeze)
+                end
+
+                def msg2str(msg)
+                    case msg
+                    when ::String
+                        msg
+                    when ::Exception
+                        "#{ msg.message } (#{ msg.class })\n" <<
+                        (msg.backtrace || []).join("\n")
+                    else
+                        msg.inspect
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/ocular/logging/kafka_logger.rb

@@ -0,0 +1,112 @@
+require "kafka"
+
+class Ocular
+    module Logging
+
+        # Most of the Logger class is copied from the Ruby Logger class source code.
+        class KafkaLogger
+
+            def initialize(settings=nil, kafka=nil)
+                @level = Severity::DEBUG
+                @formatter = Formatter.new
+
+                if kafka != nil
+                    @kafka = kafka
+                else
+                    @kafka = Kafka.new(settings)
+                end
+                @settings = settings
+
+                @producer = @kafka.producer
+            end            
+
+            def add(severity, message = nil, run_id = nil, &block)
+                severity ||= Severity::UNKNOWN
+                if severity < @level
+                    return true
+                end
+
+                if message.nil?
+                    if block_given?
+                        message = yield
+                    else
+                        message = progname
+                    end
+                end
+    
+                @producer.produce(@formatter.format_message(severity, Time.now, run_id, message), topic: @settings[:topic], partition_key: run_id)
+            end
+
+            def log_event(property, value, run_id = nil)
+                @producer.produce(@formatter.format_event(property, value, Time.now, run_id), topic: @settings[:topic], partition_key: run_id)
+            end
+
+            def log_cause(type, environment, run_id = nil)
+                @producer.produce(@formatter.format_cause(type, environment, Time.now, run_id), topic: @settings[:topic], partition_key: run_id)
+            end
+
+            def log_timing(key, value, run_id = nil)
+                @producer.produce(@formatter.format_event("timing:" + key, value, Time.now, run_id), topic: @settings[:topic], partition_key: run_id)
+            end
+
+            # Default formatter for log messages.
+            class Formatter
+                Format = "%s, [%s#%d] %5s -- %s: %s\n".freeze
+
+                attr_accessor :datetime_format
+
+                def initialize
+                    @datetime_format = nil
+                end
+
+                def format_message(severity, time, progname, msg)
+                    data = {
+                        "level" => Ocular::Logging::Severity::LABELS[severity],
+                        "ts" => format_datetime(time),
+                        "run_id" => progname,
+                        "msg" => msg2str(msg)
+                    } 
+                    return data.to_json
+                end
+
+                def format_event(property, value, time, progname)
+                    data = {
+                        "ts" => format_datetime(time),
+                        "run_id" => progname,
+                    }
+                    data[property] = value
+                    return data.to_json
+                end                
+
+                def format_cause(type, environment, time, progname)
+                    data = {
+                        "ts" => format_datetime(time),
+                        "run_id" => progname,
+                        "triggered_by" => type,
+                        "environment" => environment
+                    }
+
+                    return data.to_json
+                end
+
+            private
+
+                def format_datetime(time)
+                    time.strftime(@datetime_format || "%Y-%m-%dT%H:%M:%S.%6N ".freeze)
+                end
+
+                def msg2str(msg)
+                    case msg
+                    when ::String
+                        msg
+                    when ::Exception
+                        "#{ msg.message } (#{ msg.class })\n" <<
+                        (msg.backtrace || []).join("\n")
+                    else
+                        msg.inspect
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/ocular/logging/logging.rb

@@ -0,0 +1,4 @@
+require 'ocular/logging/severity.rb'
+require 'ocular/logging/multilogger.rb'
+require 'ocular/logging/console_logger.rb'
+require 'ocular/logging/kafka_logger.rb'

data/lib/ocular/logging/multilogger.rb

@@ -0,0 +1,52 @@
+
+require 'pp'
+
+class Ocular
+    module Logging
+        class MultiLogger
+            attr_reader :loggers
+
+            def initialize
+                @loggers = []
+            end
+
+            def add_logger(logger)
+                @loggers << logger
+            end
+
+            def add(severity, message = nil, run_id = nil, &block)
+
+                if message.nil?
+                    if block_given?
+                        message = yield
+                    else
+                        message = "N/A"
+                    end
+                end
+
+                @loggers.each do |logger|
+                    logger.add(severity, message, run_id)
+                end
+    
+            end
+
+            def log_event(property, value, run_id)
+                @loggers.each do |logger|
+                    logger.log_event(property, value, run_id)
+                end
+            end
+
+            def log_cause(type, environment, run_id)
+                @loggers.each do |logger|
+                    logger.log_cause(type, environment, run_id)
+                end
+            end
+
+            def log_timing(key, value, run_id)
+                @loggers.each do |logger|
+                    logger.log_timing(key, value, run_id)
+                end
+            end        
+        end
+    end
+end

data/lib/ocular/logging/severity.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+class Ocular
+    module Logging
+        # Logging severity.
+        module Severity
+            LABELS = %w(DEBUG INFO WARN ERROR FATAL ANY).each(&:freeze).freeze
+
+            # Low-level information, mostly for developers.
+            DEBUG = 0
+            # Generic (useful) information about system operation.
+            INFO = 1
+            # A warning.
+            WARN = 2
+            # A handleable error condition.
+            ERROR = 3
+            # An unhandleable error that results in a program crash.
+            FATAL = 4
+            # An unknown message that should always be logged.
+            UNKNOWN = 5
+        end
+    end
+end

data/lib/ocular/ocular.rb

@@ -1,6 +1,7 @@
 
 require 'ocular/version'
 require 'ocular/settings'
+require 'ocular/logging/logging'
 require 'ocular/event/eventbase'
 require 'ocular/event/eventfactory'
 require 'ocular/dsl/dsl'

data/lib/ocular/version.rb

@@ -1,3 +1,3 @@
 class Ocular
-    Version = "0.1.8"
+    Version = "0.1.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocular
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Juho Mäkinen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-15 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rye
@@ -122,6 +122,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: ruby-kafka
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -169,6 +183,12 @@ files:
 - lib/ocular/inputs/cron_input.rb
 - lib/ocular/inputs/handlers.rb
 - lib/ocular/inputs/http_input.rb
+- lib/ocular/inputs/trigger_input.rb
+- lib/ocular/logging/console_logger.rb
+- lib/ocular/logging/kafka_logger.rb
+- lib/ocular/logging/logging.rb
+- lib/ocular/logging/multilogger.rb
+- lib/ocular/logging/severity.rb
 - lib/ocular/mixin/from_file.rb
 - lib/ocular/ocular.rb
 - lib/ocular/settings.rb