dry-monitor 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e21a185d78c3e50cd1c99ddf4d211ed3650b298f
-  data.tar.gz: e103e5a459c69901f96423978e55fdf325f85f54
+  metadata.gz: 6454d8e5127c145f85a2f9e35dc21e7a84bd6037
+  data.tar.gz: c3f01289d91fa96c7aa3316b866b74fbd2524ccf
 SHA512:
-  metadata.gz: 7539abd470e9413b7882ff41f0674f2fc3bfcf860c394e4e53991611316a636f2ba76cea514d2f6178ede7677ae6b782b3844e44f806d95f6719cc906beb38b8
-  data.tar.gz: 8d97ebaba61a89e895669d1ecfa88266fe596f44c92590bffa68a5acf4dc5dcdc1fc8ff03f24f65d1966d06b38c9cb1ba28b6aa04e5ad58926304b868ca7d565
+  metadata.gz: 2ac158bd1e1b591de60c7e8afa817ea79a2ea437e5776cf8290fbdb12d5ac2c1309ee48e72078f579c702b0f288fdcac19de152fac8ccec215f369930381bfff
+  data.tar.gz: 4e52db2286bdb3cb5e94b412b767c7ea2d88f0eb9f3d77f9e17fe359e89653f2d917dd9bd1290f591fe0db45accd367dbf8f6d5d8190f7d1fe0964e373c5e896

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# v0.0.2 2017-02-02
+
+### Added
+
+* `Dry::Monitor::Rack::Middleware#on` shortcut (solnic)
+* `Dry::Monitor::Rack::Middleware#instrument` shortcut (solnic)
+* `Dry::Monitor::SQL::Logger` can be configured with a custom message template (solnic)
+
+### Changed
+
+* `Dry::Monitor::Rack::Logger#{subscribe=>attach}` and now it accepts a rack middleware instance (solnic)
+* `Dry::Monitor::Rack::Logger` appends new lines when logging `:rack.request.stop` events (solnic)
+
 # v0.0.1 2017-02-01
 
 First public release

data/lib/dry/monitor.rb

@@ -1,85 +1,5 @@
-require 'dry-equalizer'
-
-require 'dry/monitor/rack/middleware'
 require 'dry/monitor/logger'
+require 'dry/monitor/notifications'
+require 'dry/monitor/rack/middleware'
+require 'dry/monitor/rack/logger'
 require 'dry/monitor/sql/logger'
-
-module Dry
-  module Monitor
-    class Clock
-      def measure(&block)
-        start = current
-        result = block.()
-        stop = current
-        [result, ((stop - start) * 1000).round(2)]
-      end
-
-      def current
-        Time.now
-      end
-    end
-
-    CLOCK = Clock.new
-
-    class Event
-      attr_reader :id
-
-      attr_reader :info
-
-      def initialize(id, info = {})
-        @id = id
-        @info = info
-      end
-    end
-
-    class Notifications
-      attr_reader :id
-      attr_reader :events
-      attr_reader :listeners
-      attr_reader :clock
-
-      def initialize(id)
-        @id = id
-        @listeners = Hash.new { |h, k| h[k] = [] }
-        @events = {}
-        @clock = CLOCK
-      end
-
-      def event(id, info = {})
-        events[id] = Event.new(id, info)
-        self
-      end
-
-      def subscribe(event_id, listener = nil, &block)
-        listeners[event_id] << (listener || block)
-        self
-      end
-
-      def start(event_id, payload)
-        instrument(event_id, payload)
-      end
-
-      def stop(event_id, payload)
-        instrument(event_id, payload)
-      end
-
-      def instrument(event_id, payload = nil, &block)
-        event = events[event_id]
-
-        if block
-          result, time = clock.measure(&block)
-        end
-
-        listeners[event_id].each do |listener|
-          if time
-            listener.(time, event.id, payload.merge(event.info))
-          else
-            listener.(event.id, payload.merge(event.info))
-          end
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/dry/monitor/notifications.rb

@@ -0,0 +1,79 @@
+module Dry
+  module Monitor
+    class Clock
+      def measure(&block)
+        start = current
+        result = block.()
+        stop = current
+        [result, ((stop - start) * 1000).round(2)]
+      end
+
+      def current
+        Time.now
+      end
+    end
+
+    CLOCK = Clock.new
+
+    class Event
+      attr_reader :id
+
+      attr_reader :info
+
+      def initialize(id, info = {})
+        @id = id
+        @info = info
+      end
+    end
+
+    class Notifications
+      attr_reader :id
+      attr_reader :events
+      attr_reader :listeners
+      attr_reader :clock
+
+      def initialize(id)
+        @id = id
+        @listeners = Hash.new { |h, k| h[k] = [] }
+        @events = {}
+        @clock = CLOCK
+      end
+
+      def event(id, info = {})
+        events[id] = Event.new(id, info) unless events.key?(id)
+        self
+      end
+
+      def subscribe(event_id, listener = nil, &block)
+        listeners[event_id] << (listener || block)
+        self
+      end
+
+      def start(event_id, payload)
+        instrument(event_id, payload)
+      end
+
+      def stop(event_id, payload)
+        instrument(event_id, payload)
+      end
+
+      def instrument(event_id, payload = nil, &block)
+        event = events[event_id]
+
+        if block
+          result, time = clock.measure(&block)
+        end
+
+        listeners[event_id].each do |listener|
+          if time
+            listener.(time, event.id, payload.merge(event.info))
+          else
+            listener.(event.id, payload.merge(event.info))
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/dry/monitor/rack/logger.rb

@@ -0,0 +1,109 @@
+require 'dry/configurable'
+
+module Dry
+  module Monitor
+    module Rack
+      class Logger
+        extend Dry::Configurable
+
+        setting :filtered_params, %w[_csrf password]
+
+        REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+        PATH_INFO = 'PATH_INFO'.freeze
+        REMOTE_ADDR = 'REMOTE_ADDR'.freeze
+        RACK_INPUT = 'rack.input'.freeze
+        QUERY_PARAMS = 'QUERY_PARAMS'.freeze
+
+        START_MSG = %(Started %s "%s" for %s at %s).freeze
+        STOP_MSG = %(Finished %s "%s" for %s in %sms [Status: %s]\n).freeze
+        PARAMS_MSG = %(  Parameters %s).freeze
+        QUERY_MSG = %(  Query parameters %s).freeze
+        FILTERED = '[FILTERED]'.freeze
+
+        attr_reader :logger
+
+        attr_reader :config
+
+        def initialize(logger, config = self.class.config)
+          @logger = logger
+          @config = config
+        end
+
+        def attach(rack_monitor)
+          rack_monitor.on(:start) do |id, payload|
+            log_start_request(payload[:env])
+          end
+
+          rack_monitor.on(:stop) do |id, payload|
+            log_stop_request(payload[:env], payload[:status], payload[:time])
+          end
+
+          rack_monitor.on(:error) do |id, payload|
+            log_exception(payload[:exception], payload[:name])
+          end
+        end
+
+        def log_exception(e, app_name)
+          logger.error e.message
+          logger.error filter_backtrace(e.backtrace, app_name).join("\n")
+        end
+
+        def log_start_request(request)
+          info START_MSG % [
+                 request[REQUEST_METHOD],
+                 request[PATH_INFO],
+                 request[REMOTE_ADDR],
+                 Time.now
+               ]
+          log_request_params(request)
+        end
+
+        def log_stop_request(request, status, time)
+          info STOP_MSG % [
+                 request[REQUEST_METHOD],
+                 request[PATH_INFO],
+                 request[REMOTE_ADDR],
+                 time,
+                 status
+               ]
+        end
+
+        def log_request_params(request)
+          with_http_params(request[QUERY_PARAMS]) do |params|
+            info QUERY_MSG % [params.inspect]
+          end
+        end
+
+        def info(*args)
+          logger.info(*args)
+        end
+
+        def with_http_params(params)
+          params = ::Rack::Utils.parse_nested_query(params)
+          if params.size > 0
+            yield(filter_params(params))
+          end
+        end
+
+        def filter_backtrace(backtrace, app_name)
+          # TODO: what do we want to do with this?
+          backtrace.reject { |l| l.include?('gems') }
+        end
+
+        def filter_params(params)
+          params.each_with_object({}) do |(k, v), h|
+            if v.is_a?(Hash)
+              h.update(k => filter_params(v))
+            elsif v.is_a?(Array)
+              h.update(k => v.map { |m| filter_params(m) })
+            elsif config.filtered_params.include?(k)
+              h.update(k => FILTERED)
+            else
+              h[k] = v
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/monitor/rack/middleware.rb

@@ -1,115 +1,12 @@
-require 'dry/configurable'
 require 'rack/utils'
 
 module Dry
   module Monitor
     module Rack
-      class Logger
-        extend Dry::Configurable
-
-        setting :filtered_params, %w[_csrf password]
-
-        REQUEST_METHOD = 'REQUEST_METHOD'.freeze
-        PATH_INFO = 'PATH_INFO'.freeze
-        REMOTE_ADDR = 'REMOTE_ADDR'.freeze
-        RACK_INPUT = 'rack.input'.freeze
-        QUERY_PARAMS = 'QUERY_PARAMS'.freeze
-
-        START_MSG = %(Started %s "%s" for %s at %s).freeze
-        STOP_MSG = %(Finished %s "%s" for %s in %sms [Status: %s]).freeze
-        PARAMS_MSG = %(  Parameters %s).freeze
-        QUERY_MSG = %(  Query parameters %s).freeze
-        FILTERED = '[FILTERED]'.freeze
-
-        attr_reader :logger
-
-        attr_reader :config
-
-        def initialize(logger, config = self.class.config)
-          @logger = logger
-          @config = config
-        end
-
-        def subscribe(notifications)
-          notifications.subscribe(Middleware::REQUEST_START) do |id, payload|
-            log_start_request(payload[:env])
-          end
-
-          notifications.subscribe(Middleware::REQUEST_STOP) do |id, payload|
-            log_stop_request(payload[:env], payload[:status], payload[:time])
-          end
-
-          notifications.subscribe(Middleware::APP_ERROR) do |id, payload|
-            log_exception(payload[:exception], payload[:name])
-          end
-        end
-
-        def log_exception(e, app_name)
-          logger.error e.message
-          logger.error filter_backtrace(e.backtrace, app_name).join("\n")
-        end
-
-        def log_start_request(request)
-          info START_MSG % [
-                 request[REQUEST_METHOD],
-                 request[PATH_INFO],
-                 request[REMOTE_ADDR],
-                 Time.now
-               ]
-          log_request_params(request)
-        end
-
-        def log_stop_request(request, status, time)
-          info STOP_MSG % [
-                 request[REQUEST_METHOD],
-                 request[PATH_INFO],
-                 request[REMOTE_ADDR],
-                 time,
-                 status
-               ]
-        end
-
-        def log_request_params(request)
-          with_http_params(request[QUERY_PARAMS]) do |params|
-            info QUERY_MSG % [params.inspect]
-          end
-        end
-
-        def info(*args)
-          logger.info(*args)
-        end
-
-        def with_http_params(params)
-          params = ::Rack::Utils.parse_nested_query(params)
-          if params.size > 0
-            yield(filter_params(params))
-          end
-        end
-
-        def filter_backtrace(backtrace, app_name)
-          # TODO: what do we want to do with this?
-          backtrace.reject { |l| l.include?('gems') }
-        end
-
-        def filter_params(params)
-          params.each_with_object({}) do |(k, v), h|
-            if v.is_a?(Hash)
-              h.update(k => filter_params(v))
-            elsif v.is_a?(Array)
-              h.update(k => v.map { |m| filter_params(m) })
-            elsif config.filtered_params.include?(k)
-              h.update(k => FILTERED)
-            else
-              h[k] = v
-            end
-          end
-        end
-      end
-
       class Middleware
-        REQUEST_START = :'request.start'
-        REQUEST_STOP = :'request.stop'
-        APP_ERROR = :'app.error'
+        REQUEST_START = :'rack.request.start'
+        REQUEST_STOP = :'rack.request.stop'
+        REQUEST_ERROR = :'rack.request.error'
 
         attr_reader :app
         attr_reader :notifications
@@ -119,13 +16,21 @@ module Dry
 
           notifications.event(REQUEST_START)
           notifications.event(REQUEST_STOP)
-          notifications.event(APP_ERROR)
+          notifications.event(REQUEST_ERROR)
         end
 
         def new(app)
           self.class.new(notifications, app)
         end
 
+        def on(event_id, &block)
+          notifications.subscribe(:"rack.request.#{event_id}", &block)
+        end
+
+        def instrument(event_id, *args, &block)
+          notifications.instrument(:"rack.request.#{event_id}", *args, &block)
+        end
+
         def call(env)
           notifications.start(REQUEST_START, env: env)
           response, time = CLOCK.measure { app.call(env) }

data/lib/dry/monitor/sql/logger.rb

@@ -9,17 +9,20 @@ module Dry
 
         setting :theme, Rouge::Themes::Gruvbox
         setting :colorize, true
+        setting :message_template, %(  Loaded %s in %sms %s).freeze
 
         attr_reader :config
         attr_reader :logger
         attr_reader :formatter
         attr_reader :lexer
+        attr_reader :template
 
         def initialize(logger, config = self.class.config)
           @logger = logger
           @config = config
           @formatter = Rouge::Formatters::Terminal256.new(config.theme)
           @lexer = Rouge::Lexers::SQL.new
+          @template = config.message_template
         end
 
         def subscribe(notifications)
@@ -29,7 +32,7 @@ module Dry
         end
 
         def log_query(time, name, query)
-          logger.info "  Loaded #{name.inspect} in #{time}ms #{colorize(query)}"
+          logger.info template % [name.inspect, time, colorize(query)]
         end
 
         private

data/lib/dry/monitor/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Monitor
-    VERSION = '0.0.1'.freeze
+    VERSION = '0.0.2'.freeze
   end
 end

data/spec/integration/rack_middleware_spec.rb

@@ -30,7 +30,7 @@ RSpec.describe Dry::Monitor::Rack::Middleware do
 
     before do
       File.open(log_file_path, 'w').close
-      rack_logger.subscribe(notifications)
+      rack_logger.attach(middleware)
     end
 
     it 'triggers start/stop events for with a rack request' do
@@ -48,4 +48,18 @@ RSpec.describe Dry::Monitor::Rack::Middleware do
       expect(log_file_content).to include('Query parameters {"_csrf"=>"[FILTERED]", "password"=>"[FILTERED]", "user"=>{"password"=>"[FILTERED]"}, "other"=>[{"password"=>"[FILTERED]"}, {"password"=>"[FILTERED]"}], "foo"=>"bar", "one"=>"1"}')
     end
   end
+
+  describe '#on' do
+    it 'subscribe a listener to a specific request event' do
+      captured = []
+
+      middleware.on(:error) do |id, payload|
+        captured << payload
+      end
+
+      middleware.instrument(:error, exception: 'oops')
+
+      expect(captured).to eql([exception: 'oops'])
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-monitor
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-01 00:00:00.000000000 Z
+date: 2017-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rouge
@@ -115,6 +115,8 @@ files:
 - lib/dry-monitor.rb
 - lib/dry/monitor.rb
 - lib/dry/monitor/logger.rb
+- lib/dry/monitor/notifications.rb
+- lib/dry/monitor/rack/logger.rb
 - lib/dry/monitor/rack/middleware.rb
 - lib/dry/monitor/sql/logger.rb
 - lib/dry/monitor/version.rb