hoodoo 1.5.2 → 1.6.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODRjNTI3Y2YyMGU1NThkYTVlNmI0YzZjMzJiNzE3MDg3NGU1Zjg4OQ==
+    MmIwZDk4ODJmMWM2MGQ0MjIwNWMwYTRjZTZlZjE3NDM5NWUxOTgzYg==
   data.tar.gz: !binary |-
-    ZTljMjA0NWU4ZTY0NjU4OGNiNTg5NDBiNzU5OWU4ZTA2MmYwNzJjNQ==
+    MDA4ODMwYjc2Zjc1MTQ1Njk0YzMxNzRiMTFjMDRkYTdmMTI2MTA3YQ==
 SHA512:
   metadata.gz: !binary |-
-    YWI1MDQwNzgzMjVmMTExM2JmM2QwYTI2YmI1OWU1ZjM2ZmE3ZWVkZWViMmE0
-    MzBiN2MxYThiYzNlYjcyY2ZlNmY0YmEzNzg4NjIwMDQyYWQ5ZmUwOWMzZWJj
-    YjkxMGNjNDA2MjdmM2FhODg0OWZkNzUwOGJkNmIyNTQ5YjQ0N2U=
+    MzRlYzJiNDcyMjcxNzg1NWI0MGU2Y2IyMTFmZTI5Y2I4NTkxNGE1YmZkZWM2
+    ZWM4MmZhNzZkNjNhZmY0ZDM5Mjg5Mjg4NDgzYTM0YzExNDAwNDk0MDkwODIz
+    MThkNGYwMWM3Njg3ZGQwNmIyMjM3ZjcxMzg5MDU2YzZiMzk0NmE=
   data.tar.gz: !binary |-
-    YzUzY2M0M2U4OWMyNWY1ZGQzYjU5YjAwM2EwZjY2OTU4ZDA0NTc1OThmZDI2
-    ODVhMTFjZDkwYTEwOTZhYzk1Zjk5MzAyMzRlY2FjOTlmZmI0NGIxZDAwN2E5
-    MmIwNDMwYTNiZDY5NTc5YjgzNzA1OTk4ZTQ2ZmZmMzNlZDJmMjA=
+    YWViZTVjNDRkZTM1ZTYzZmRlYjg5YmU2YThjYTNjN2RhYTAyZGNmNjQxZmY2
+    NDQ3ZDM2MmVmMGRmMzg2YWI1MTk5NDJlNWVkZWM2ZmNlNDZmYmM5NjUwMjYw
+    MzI1MzAxMDQ4MTMwY2JmN2NiNTI1ZTk0MmM1NTE2ZTU2NGU4ZTE=

data/lib/hoodoo/logger/logger.rb

@@ -103,13 +103,17 @@ module Hoodoo
     # Internal default timeouts may even mean that the writer is still running
     # (possibly entirely hung).
     #
-    # +writer_instance+:: An _instance_ of a subclass of
-    #                     Hoodoo::Logger::FastWriter or
-    #                     Hoodoo::Logger::SlowWriter.
+    # +writer_instances+:: One or more _instances_ of a subclass of
+    #                      Hoodoo::Logger::FastWriter or
+    #                      Hoodoo::Logger::SlowWriter, passed as one or
+    #                      more comma-separated parameters.
     #
-    def remove( writer_instance )
-      communicator = @writers[ writer_instance ]
-      @pool.remove( communicator ) unless communicator.nil?
+    def remove( *writer_instances )
+      writer_instances.each do | writer_instance |
+        communicator = @writers[ writer_instance ]
+        @pool.remove( communicator ) unless communicator.nil?
+        @writers.delete( writer_instance )
+      end
     end
 
     # Remove all writer instances from this logger.
@@ -124,6 +128,40 @@ module Hoodoo
       @writers = {}
     end
 
+    # Does this log instance's collection of writers include the given writer
+    # instance? Returns +true+ if so, else +false+.
+    #
+    # +writer_instance+:: An _instance_ of a subclass of
+    #                     Hoodoo::Logger::FastWriter or
+    #                     Hoodoo::Logger::SlowWriter.
+    #
+    def include?( writer_instance )
+      @writers.has_key?( writer_instance )
+    end
+
+    alias_method( :includes?, :include? )
+
+    # Does this log instance's collection of writers include any writer
+    # instances which are of the given writer _class_? Returns +true+ if so,
+    # else +false+.
+    #
+    # This is slower than #include? so try to work with writer instance
+    # queries rather than writer class queries if you can.
+    #
+    # +writer_class+:: A _subclass_ (class reference, not instance) of
+    #                  Hoodoo::Logger::FastWriter or
+    #                  Hoodoo::Logger::SlowWriter.
+    #
+    def include_class?( writer_class )
+      @writers.keys.each do | writer_instance |
+        return true if writer_instance.is_a?( writer_class )
+      end
+
+      return false
+    end
+
+    alias_method( :includes_class?, :include_class? )
+
     # Returns an array of all log writer instances currently in use, in order
     # of addition. See #add.
     #

data/lib/hoodoo/services/middleware/amqp_log_writer.rb

@@ -65,25 +65,22 @@ module Hoodoo; module Services
       def report( level, component, code, data )
         return if @alchemy.nil?
 
-        # Take care with Symbol keys in 'data' vs string keys in e.g. 'Session'.
-
-        data[ :id ] ||= Hoodoo::UUID.generate()
+        # Take care with Symbol keys in 'data' vs string keys in e.g. 'session'.
 
         session = data[ :session ] || {}
         message = {
+          :id                   => data[ :id ],
+          :level                => level,
+          :component            => component,
+          :code                 => code,
+          :reported_at          => Time.now.iso8601( 12 ),
 
-          :id             => data[ :id ],
-          :level          => level,
-          :component      => component,
-          :code           => code,
-          :reported_at    => Time.now.iso8601( 12 ),
-
-          :data           => data,
-
-          :interaction_id => data[ :interaction_id ],
-          :caller_id      => session[ 'caller_id' ],
-          :identity       => ( session[ 'identity' ] || {} ).to_h
+          :interaction_id       => data[ :interaction_id ],
+          :data                 => data,
 
+          :caller_id            => session[ 'caller_id'            ],
+          :caller_identity_name => session[ 'caller_identity_name' ],
+          :identity             => ( session[ 'identity' ] || {} ).to_h
         }.to_json()
 
         @alchemy.send_message_to_service( @routing_key, { "body" => message } )

data/lib/hoodoo/services/middleware/middleware.rb

@@ -159,15 +159,16 @@ module Hoodoo; module Services
     # middleware for simplicity/speed at parse time.
     #
     DEFAULT_TEST_SESSION.from_h!( {
-      'session_id'     => '01234567890123456789012345678901',
-      'expires_at'     => ( Time.now + 172800 ).utc.iso8601,
-      'caller_version' => 1,
-      'caller_id'      =>                  'c5ea12fb7f414a46850e73ee1bf6d95e',
-      'identity'       => { 'caller_id' => 'c5ea12fb7f414a46850e73ee1bf6d95e' },
-      'permissions'    => Hoodoo::Services::Permissions.new( {
+      'session_id'           => '01234567890123456789012345678901',
+      'expires_at'           => ( Time.now + 172800 ).utc.iso8601,
+      'caller_version'       => 1,
+      'caller_id'            =>                  'c5ea12fb7f414a46850e73ee1bf6d95e',
+      'caller_identity_name' =>                  'c5ea12fb7f414a46850e73ee1bf6d95e',
+      'identity'             => { 'caller_id' => 'c5ea12fb7f414a46850e73ee1bf6d95e' },
+      'permissions'          => Hoodoo::Services::Permissions.new( {
         'default' => { 'else' => Hoodoo::Services::Permissions::ALLOW }
       } ).to_h,
-      'scoping'        => {
+      'scoping' => {
         'authorised_http_headers' => Hoodoo::Client::Headers::HEADER_TO_PROPERTY.map() { | key, sub_hash |
           sub_hash[ :header ] if sub_hash[ :secured ] == true
         }.compact
@@ -322,6 +323,29 @@ module Hoodoo; module Services
       self.send( :add_file_logging, base_path )
     end
 
+    # Set verbose logging. With verbose logging enabled, additional payload
+    # data is added - most notably, full session details (where possible)
+    # are included in each log message. These can increase log data size
+    # considerably, but may be useful if you encounter session-related
+    # errors or general operational issues and need log data to provide more
+    # insights.
+    #
+    # Verbose logging is _disabled_ by default.
+    #
+    # +verbose+:: +true+ to enable verbose logging, +false+ to disable it.
+    #             The default is +false+.
+    #
+    def self.set_verbose_logging( verbose )
+      @@verbose_logging = verbose
+    end
+
+    # Returns +true+ if verbose logging is enabled, else +false+. For more,
+    # see ::set_verbose_logging.
+    #
+    def self.verbose_logging?
+      defined?( @@verbose_logging ) ? @@verbose_logging : false
+    end
+
     # A Hoodoo::Services::Session instance to use for tests or when no
     # local Memcached instance is known about (environment variable
     # +MEMCACHED_HOST+ is not set). The session is (eventually) read each
@@ -1037,6 +1061,55 @@ module Hoodoo; module Services
       end
     end
 
+    # Build common log information for the 'data' part of a payload based
+    # on the given interaction. Returned as a Hash with Symbol keys.
+    #
+    # +interaction+:: Hoodoo::Services::Interaction describing a request.
+    #                 A +context+ and +interaction_id+ are expected. The
+    #                 +target_interface+ and +requested_action+ are optional
+    #                 and if present result in a <tt>:target</tt> entry in
+    #                 the returned Hash. The +context.session+ value if
+    #                 present will be included in a <tt>:session</tt> entry;
+    #                 if verbose logging is enabled this will be quoted in
+    #                 full, else only identity-related parts are recorded.
+    #
+    def build_common_log_data_for( interaction )
+
+      session   = interaction.context.session
+      interface = interaction.target_interface
+      action    = interaction.requested_action
+
+      data = {
+        :id             => Hoodoo::UUID.generate(),
+        :interaction_id => interaction.interaction_id
+      }
+
+      unless session.nil?
+        if self.class.verbose_logging?
+          data[ :session ] = session.to_h
+        else
+          data[ :session ] =
+          {
+            'session_id'           => session.session_id,
+            'caller_id'            => session.caller_id,
+            'caller_version'       => session.caller_version,
+            'caller_identity_name' => session.caller_identity_name,
+            'identity'             => Hoodoo::Utilities.stringify( ( session.identity || {} ).to_h() )
+          }
+        end
+      end
+
+      unless interface.nil? || action.nil?
+        data[ :target ] = {
+          :resource => ( interface.resource || '' ).to_s,
+          :version  =>   interface.version,
+          :action   => ( action || '' ).to_s,
+        }
+      end
+
+      return data
+    end
+
     # Make an "inbound" call log based on the given interaction.
     #
     # +interaction+:: Hoodoo::Services::Interaction describing the inbound
@@ -1049,6 +1122,8 @@ module Hoodoo; module Services
     #
     def log_inbound_request( interaction )
 
+      data = build_common_log_data_for( interaction )
+
       # Annoying dance required to extract all HTTP header data from Rack.
 
       env     = interaction.rack_request.env
@@ -1059,27 +1134,26 @@ module Hoodoo; module Services
       headers[ 'CONTENT_TYPE'   ] = env[ 'CONTENT_TYPE'   ]
       headers[ 'CONTENT_LENGTH' ] = env[ 'CONTENT_LENGTH' ]
 
-      data = {
-        :interaction_id => interaction.interaction_id,
-        :payload        => {
-          :method  => env[ 'REQUEST_METHOD', ],
-          :scheme  => env[ 'rack.url_scheme' ],
-          :host    => env[ 'SERVER_NAME'     ],
-          :port    => env[ 'SERVER_PORT'     ],
-          :script  => env[ 'SCRIPT_NAME'     ],
-          :path    => env[ 'PATH_INFO'       ],
-          :query   => env[ 'QUERY_STRING'    ],
-          :headers => headers
-        }
+      data[ :payload ] = {
+        :method  => env[ 'REQUEST_METHOD', ],
+        :scheme  => env[ 'rack.url_scheme' ],
+        :host    => env[ 'SERVER_NAME'     ],
+        :port    => env[ 'SERVER_PORT'     ],
+        :script  => env[ 'SCRIPT_NAME'     ],
+        :path    => env[ 'PATH_INFO'       ],
+        :query   => env[ 'QUERY_STRING'    ],
+        :headers => headers
       }
 
       # Deal with body data and security issues.
 
-      secure = true
+      secure    = true
+      interface = interaction.target_interface
+      action    = interaction.requested_action
 
-      unless interaction.target_interface.nil? || interaction.requested_action.nil?
-        secure_log_actions = interaction.target_interface.secure_log_for()
-        secure_type = secure_log_actions[ interaction.requested_action ]
+      unless interface.nil? || action.nil?
+        secure_log_actions = interface.secure_log_for()
+        secure_type        = secure_log_actions[ action ]
 
         # Allow body logging if there's no security specified for this action
         # or the security is specified for the response only (since we log the
@@ -1089,14 +1163,6 @@ module Hoodoo; module Services
         # as will any other unexpected value that might get specified.
 
         secure = false if secure_type.nil? || secure_type == :response
-
-        # Fill in unrelated useful data since we know it is available here.
-
-        data[ :target ] = {
-          :resource => ( interaction.target_interface.resource || '' ).to_s,
-          :version  =>   interaction.target_interface.version,
-          :action   => ( interaction.requested_action || '' ).to_s
-        }
       end
 
       # Compile the remaining log payload and send it.
@@ -1143,17 +1209,7 @@ module Hoodoo; module Services
       #
       return if ( context.response.halt_processing? )
 
-      # Data as per Hoodoo::Logger.
-
-      data = {
-        :interaction_id => interaction.interaction_id,
-        :session        => ( interaction.context.session || {} ).to_h,
-        :target         => {
-          :resource => ( interface.resource || '' ).to_s,
-          :version  =>   interface.version,
-          :action   => ( action || '' ).to_s,
-        }
-      }
+      data = build_common_log_data_for( interaction )
 
       # Don't bother logging list responses - they could be huge - instead
       # log all list-related parameters from the inbound request. At least
@@ -1174,7 +1230,7 @@ module Hoodoo; module Services
 
         unless interface.nil? || action.nil?
           secure_log_actions = interface.secure_log_for()
-          secure_type = secure_log_actions[ action ]
+          secure_type        = secure_log_actions[ action ]
 
           # Allow body logging if there's no security specified for this action
           # or the security is specified for the request only (since we log the
@@ -1211,25 +1267,22 @@ module Hoodoo; module Services
     #                 the interaction currently being logged.
     #
     def log_outbound_response( interaction, rack_data )
-      secure = true
-      id     = nil
-      level  = if interaction.context.response.halt_processing?
-        :error
-      else
-        :info
-      end
 
-      data = {
-        :interaction_id => interaction.interaction_id,
-        :payload        => {
-          :http_status_code => rack_data[ 0 ].to_i,
-          :http_headers     => rack_data[ 1 ]
-        }
+      level = interaction.context.response.halt_processing? ? :error : :info
+      data  = build_common_log_data_for( interaction )
+
+      data[ :payload ] = {
+        :http_status_code => rack_data[ 0 ].to_i,
+        :http_headers     => rack_data[ 1 ]
       }
 
-      unless interaction.target_interface.nil? || interaction.requested_action.nil?
-        secure_log_actions = interaction.target_interface.secure_log_for()
-        secure_type = secure_log_actions[ interaction.requested_action ]
+      secure    = true
+      interface = interaction.target_interface
+      action    = interaction.requested_action
+
+      unless interface.nil? || action.nil?
+        secure_log_actions = interface.secure_log_for()
+        secure_type = secure_log_actions[ action ]
 
         # Allow body logging if there's no security specified for this action
         # or the security is specified for the request only (since we log the
@@ -1239,12 +1292,6 @@ module Hoodoo; module Services
         # as will any other unexpected value that might get specified.
 
         secure = false if secure_type.nil? || secure_type == :request
-
-        data[ :target ] = {
-          :resource => ( interaction.target_interface.resource || '' ).to_s,
-          :version  =>   interaction.target_interface.version,
-          :action   => ( interaction.requested_action || '' ).to_s
-        }
       end
 
       if secure == false || level == :error
@@ -1263,7 +1310,9 @@ module Hoodoo; module Services
             # persistence layers store the item as an error with the correct ID.
 
             body = ::JSON.parse( body )
-            id   = body[ 'id' ]
+
+            uuid = body[ 'id' ]
+            data[ :id ] = uuid unless uuid.nil?
           rescue
           end
 
@@ -1275,9 +1324,6 @@ module Hoodoo; module Services
         data[ :payload ][ :response_body ] = body
       end
 
-      data[ :id      ] = id unless id.nil?
-      data[ :session ] = interaction.context.session.to_h unless interaction.context.session.nil?
-
       @@logger.report(
         level,
         :Middleware,
@@ -1310,17 +1356,14 @@ module Hoodoo; module Services
 
       return unless @@logger.report?( :debug )
 
+      data = build_common_log_data_for( interaction )
+
       scheme         = interaction.rack_request.scheme         || 'unknown_scheme'
       host_with_port = interaction.rack_request.host_with_port || 'unknown_host'
       full_path      = interaction.rack_request.fullpath       || '/unknown_path'
 
-      data = {
-        :full_uri       => "#{ scheme }://#{ host_with_port }#{ full_path }",
-        :interaction_id => interaction.interaction_id,
-        :payload        => { 'args' => args }
-      }
-
-      data[ :session ] = interaction.context.session.to_h unless interaction.context.session.nil?
+      data[ :full_uri ] = "#{ scheme }://#{ host_with_port }#{ full_path }"
+      data[ :payload  ] = { 'args' => args }
 
       @@logger.report(
         :debug,
@@ -1353,6 +1396,35 @@ module Hoodoo; module Services
     def respond_for( interaction, preflight = false )
       interaction.context.response.body = '' if preflight
 
+      # Oddly placed code for efficiency and sanity.
+      #
+      # When #log_outbound_response is called below, it would make sense to
+      # use its existing code path for logging errors and include a variant of
+      # the "if" below to add the X-Error-Logged-Via-Alchemy HTTP header if
+      # required down at that level.
+      #
+      # However, we want the Rack response payload all wrapped up for the log
+      # and it's generated here, then passed in; somehow the logging method
+      # would need to update the now-compiled Rack data, or we generate the
+      # Rack data again on exit, but then the logged Rack data would be wrong.
+      #
+      # To solve all this, just deal with the an-error-was-logged header here,
+      # before we log anything or generate Rack information.
+
+      if (
+           interaction.context.response.halt_processing? &&
+           self.class.on_queue?  &&
+           defined?( @@alchemy ) &&
+           @@logger.include_class?( Hoodoo::Services::Middleware::AMQPLogWriter )
+         )
+
+        interaction.context.response.add_header(
+          'X-Error-Logged-Via-Alchemy',
+          'yes',
+          true
+        )
+      end
+
       rack_data = interaction.context.response.for_rack()
       log_outbound_response( interaction, rack_data )
 

data/lib/hoodoo/services/services/session.rb

@@ -32,6 +32,14 @@ module Hoodoo
       #
       attr_accessor :caller_id
 
+      # An optional property of a session is the Caller's "identity name",
+      # a generic way to refer to this Caller which will appear in logs.
+      # The use is up to the session creator, in combination with whatever
+      # logging engine is in use; if it ascribes meaning to the identity
+      # name, then the session creator must ensure it comforms.
+      #
+      attr_accessor :caller_identity_name
+
       # Callers can change; if so, related sessions must be invalidated.
       # This must be achieved by keeping a version count on the Caller. A
       # session is associated with a particular Caller version and if the
@@ -192,7 +200,7 @@ module Hoodoo
                                      self.to_h(),
                                      TTL )
 
-        rescue Exception => exception
+        rescue => exception
 
           # Log error and return nil if the session can't be parsed
           #
@@ -245,7 +253,7 @@ module Hoodoo
             end
           end
 
-        rescue Exception => exception
+        rescue => exception
 
           # Log error and return nil if the session can't be parsed
           #
@@ -301,7 +309,7 @@ module Hoodoo
             return :ok
           end
 
-        rescue Exception => exception
+        rescue => exception
 
           # Log error and return nil if the session can't be parsed
           #
@@ -337,7 +345,7 @@ module Hoodoo
             return :not_found
           end
 
-        rescue Exception => exception
+        rescue => exception
 
           # Log error and return nil if the session can't be parsed
           #
@@ -376,6 +384,7 @@ module Hoodoo
           session_id
           caller_id
           caller_version
+          caller_identity_name
 
         ).each do | property |
           value = self.send( property )
@@ -420,6 +429,7 @@ module Hoodoo
           session_id
           caller_id
           caller_version
+          caller_identity_name
 
         ).each do | property |
           value = hash[ property ]
@@ -549,8 +559,9 @@ module Hoodoo
           raise 'Hoodoo::Services::Session.connect_to_memcached: The Memcached connection host data is nil or empty'
         end
 
-        stats   = nil
-        mclient = nil
+        exception = nil
+        stats     = nil
+        mclient   = nil
 
         begin
           @@dalli_clients         ||= {}
@@ -565,13 +576,17 @@ module Hoodoo
 
           stats = @@dalli_clients[ host ].stats()
 
-        rescue Exception => e
-          stats = nil
+        rescue => e
+          exception = e
 
         end
 
         if stats.nil?
-          raise "Hoodoo::Services::Session.connect_to_memcached: Cannot connect to Memcached at '#{ host }'"
+          if exception.nil?
+            raise "Hoodoo::Services::Session.connect_to_memcached: Did not get back meaningful data from Memcached at '#{ host }'"
+          else
+            raise "Hoodoo::Services::Session.connect_to_memcached: Cannot connect to Memcached at '#{ host }': #{ exception.to_s }"
+          end
         else
           return @@dalli_clients[ host ]
         end

data/lib/hoodoo/version.rb

@@ -12,6 +12,6 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, ensure that the date in
   # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
   #
-  VERSION = '1.5.2'
+  VERSION = '1.6.0'
 
 end

data/spec/logger/logger_spec.rb

@@ -51,7 +51,7 @@ describe Hoodoo::Logger do
       @logger.error( 'Three instances of StreamWriter' )
     end
 
-    it 'removes requested instances' do
+    it 'removes a requested instance' do
       @logger.remove( @stderr_2 )
 
       expect( @stderr_1 ).to receive( :report ).once
@@ -62,6 +62,17 @@ describe Hoodoo::Logger do
       @logger.error( 'Two instances of StreamWriter' )
     end
 
+    it 'removes two requested instances' do
+      @logger.remove( @stderr_3, @stderr_2 )
+
+      expect( @stderr_1 ).to receive( :report ).once
+      expect( @stderr_2 ).to_not receive( :report )
+      expect( @stderr_3 ).to_not receive( :report )
+      expect( $stderr ).to_not receive( :puts )
+
+      @logger.error( 'One instance of StreamWriter' )
+    end
+
     it 'removes all instances' do
       @logger.remove_all
 
@@ -161,6 +172,61 @@ describe Hoodoo::Logger do
 
   # ===========================================================================
 
+  context 'enquiries' do
+    before :each do
+      @logger = described_class.new
+    end
+
+    it 'via include(s)? work' do
+      a = Hoodoo::Logger::StreamWriter.new( $stderr )
+      b = Hoodoo::Logger::StreamWriter.new( $stderr )
+      c = Hoodoo::Logger::StreamWriter.new( $stderr )
+
+      @logger.add( a, b )
+
+      expect( @logger.include?( a ) ).to eq( true  )
+      expect( @logger.include?( b ) ).to eq( true  )
+      expect( @logger.include?( c ) ).to eq( false )
+
+      expect( @logger.includes?( a ) ).to eq( true  )
+      expect( @logger.includes?( b ) ).to eq( true  )
+      expect( @logger.includes?( c ) ).to eq( false )
+    end
+
+    it 'via include(s)_class? work' do
+      a = Hoodoo::Logger::StreamWriter.new( $stderr )
+      b = Hoodoo::Logger::StreamWriter.new( $stderr )
+      c = Hoodoo::Logger::FileWriter.new( 'file1' )
+      d = Hoodoo::Logger::FileWriter.new( 'file2' )
+
+      @logger.add( a, b )
+
+      expect( @logger.include_class?( Hoodoo::Logger::StreamWriter ) ).to eq( true  )
+      expect( @logger.include_class?( Hoodoo::Logger::FileWriter   ) ).to eq( false )
+
+      expect( @logger.includes_class?( Hoodoo::Logger::StreamWriter ) ).to eq( true  )
+      expect( @logger.includes_class?( Hoodoo::Logger::FileWriter   ) ).to eq( false )
+
+      @logger.add( c, d )
+
+      expect( @logger.include_class?( Hoodoo::Logger::StreamWriter ) ).to eq( true )
+      expect( @logger.include_class?( Hoodoo::Logger::FileWriter   ) ).to eq( true )
+
+      expect( @logger.includes_class?( Hoodoo::Logger::StreamWriter ) ).to eq( true )
+      expect( @logger.includes_class?( Hoodoo::Logger::FileWriter   ) ).to eq( true )
+
+      @logger.remove( a, b )
+
+      expect( @logger.include_class?( Hoodoo::Logger::StreamWriter ) ).to eq( false )
+      expect( @logger.include_class?( Hoodoo::Logger::FileWriter   ) ).to eq( true  )
+
+      expect( @logger.includes_class?( Hoodoo::Logger::StreamWriter ) ).to eq( false )
+      expect( @logger.includes_class?( Hoodoo::Logger::FileWriter   ) ).to eq( true  )
+    end
+  end
+
+  # ===========================================================================
+
   context 'legacy logging' do
     before :each do
       @logger = described_class.new

data/spec/services/middleware/amqp_log_writer_spec.rb

@@ -35,6 +35,7 @@ describe Hoodoo::Services::Middleware::AMQPLogWriter do
     @identity_id_1    = Hoodoo::UUID.generate
     @identity_id_2    = Hoodoo::UUID.generate
     @identity_id_3    = Hoodoo::UUID.generate
+    @identity_id_4    = Hoodoo::UUID.generate
 
     @authorised_ids   = [ Hoodoo::UUID.generate, Hoodoo::UUID.generate ]
     @authorised_codes = [ 'CODE_A', 'CODE_B' ]
@@ -50,6 +51,8 @@ describe Hoodoo::Services::Middleware::AMQPLogWriter do
       :authorised_codes => @authorised_codes
     }
 
+    @session.caller_identity_name = @identity_id_4
+
     @alchemy = OpenStruct.new
     @queue   = 'foo.bar'
     @logger  = described_class.new( @alchemy, @queue )
@@ -65,22 +68,28 @@ describe Hoodoo::Services::Middleware::AMQPLogWriter do
       interaction_id = Hoodoo::UUID.generate
       data           = {
         :id             => id,
-        :session        => @session.to_h(),
-        :interaction_id => interaction_id
+        :interaction_id => interaction_id,
+        :session        =>
+        {
+          'caller_id'            => @session.caller_id,
+          'caller_identity_name' => @session.caller_identity_name,
+          'identity'             => @session.identity.to_h()
+        }
       }
 
       expected_hash  = {
-        :id             => id,
-        :level          => 'warn',
-        :component      => component,
-        :code           => code,
-        :reported_at    => reported_at,
+        :id                   => id,
+        :level                => 'warn',
+        :component            => component,
+        :code                 => code,
+        :reported_at          => reported_at,
 
-        :data           => data,
+        :interaction_id       => interaction_id,
+        :data                 => data,
 
-        :interaction_id => interaction_id,
-        :caller_id      => @session.caller_id,
-        :identity       => Hoodoo::Utilities.stringify( @session.identity.to_h )
+        :caller_id            => @caller_id,
+        :caller_identity_name => @identity_id_4,
+        :identity             => Hoodoo::Utilities.stringify( @session.identity.to_h )
       }
 
       expect( @alchemy ).to receive( :send_message_to_service ).with( @queue, { "body" => expected_hash.to_json } ).once

data/spec/services/middleware/middleware_logging_spec.rb

@@ -123,13 +123,6 @@ describe Hoodoo::Services::Middleware do
       end
     end
 
-    def app
-      Rack::Builder.new do
-        use Hoodoo::Services::Middleware
-        run TestLogService.new
-      end
-    end
-
     it 'has the expected "test" mode loggers' do
       instances = force_logging_to( 'test' )
 
@@ -235,9 +228,91 @@ describe Hoodoo::Services::Middleware do
       expect( instances[ 0 ] ).to be_a( Hoodoo::Services::Middleware::AMQPLogWriter )
       expect( Hoodoo::Services::Middleware.logger.level ).to eq( :info )
     end
+
+    # When logging to Alchemy, the middleware should set an
+    # "X-Error-Logged-Via-Alchemy" HTTP header. An Alchemy router/edge
+    # splitter component can use this to avoid double-logging error data
+    # if it implements a middleware-based approach to error reporting.
+    #
+    context '"X-Error-Logged-Via-Alchemy" HTTP header is set for' do
+      before :each do
+        force_logging_to( 'development' )
+        expect_any_instance_of(FakeAlchemy).to receive(:send_message_to_service).at_least(:once)
+      end
+
+      it 'service errors' do
+        expect_any_instance_of( TestLogImplementation ).to receive( :show ) do | instance, context |
+          context.response.not_found( context.request.ident )
+        end
+
+        spec_helper_silence_stdout do
+          get '/v1/test_log/hello', nil, { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+        end
+
+        expect( last_response.headers[ 'X-Error-Logged-Via-Alchemy' ] ).to eq( 'yes' )
+        expect( last_response.status ).to eq( 404 )
+      end
+
+      it 'service exceptions' do
+        expect_any_instance_of( TestLogImplementation ).to receive( :show ) do
+          raise "boo!"
+        end
+
+        spec_helper_silence_stdout do
+          get '/v1/test_log/hello', nil, { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+        end
+
+        expect( last_response.headers[ 'X-Error-Logged-Via-Alchemy' ] ).to eq( 'yes' )
+        expect( last_response.status ).to eq( 500 )
+      end
+
+      context 'invalid' do
+        before :each do
+          @old_test_session = Hoodoo::Services::Middleware.test_session()
+        end
+
+        after :each do
+          Hoodoo::Services::Middleware.set_test_session( @old_test_session )
+        end
+
+        it 'session errors' do
+          Hoodoo::Services::Middleware.set_test_session( nil )
+
+          spec_helper_silence_stdout do
+            get '/v1/test_log/hello', nil, { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+          end
+
+          expect( last_response.headers[ 'X-Error-Logged-Via-Alchemy' ] ).to eq( 'yes' )
+          expect( last_response.status ).to eq( 401 )
+        end
+
+        it 'permission errors' do
+          session             = @old_test_session.dup()
+          session.permissions = Hoodoo::Services::Permissions.new # Default is 'deny all'
+
+          Hoodoo::Services::Middleware.set_test_session( session )
+
+          spec_helper_silence_stdout do
+            get '/v1/test_log/hello', nil, { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+          end
+
+          expect( last_response.headers[ 'X-Error-Logged-Via-Alchemy' ] ).to eq( 'yes' )
+          expect( last_response.status ).to eq( 403 )
+        end
+      end
+
+      # Middleware exceptions are not tested. There's no way to know the kind
+      # of failure that might happen in the real-world and the point at which
+      # the exception occurs in the processing chain may influence whether or
+      # not the header gets set. We might end up with double logging from an
+      # router/edge splitter in such cases, but that's acceptable for what
+      # should be an extremely rare event.
+
+    end
   end
 
-  context 'secure logging' do
+  context 'with' do
+
     class HashLogger < Hoodoo::Logger::FastWriter
       @@log_data = []
 
@@ -301,56 +376,109 @@ describe Hoodoo::Services::Middleware do
       end
     end
 
-    # To test_log, 'create' says secure for 'request'
-    #
-    it 'does not log creation requests unexpectedly' do
-      post '/v1/test_log', '{ "foo": "bar" }', { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+    context 'verbose logging' do
+      context 'which is turned off' do
+        it 'by default' do
+          expect( Hoodoo::Services::Middleware.verbose_logging? ).to eq( false )
+        end
 
-      inbound, result, outbound = get_data_for( :create )
-      check_common_entries( 'TestLog', 1, 'create', inbound.last, result.first, outbound.first )
+        it 'and omits non-identity information in the session section' do
+          get '/v1/test_log/hello', nil, { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
 
-      entry = inbound.last;   expect( entry[ :data ][ :payload ] ).to_not have_key( :body )
-      entry = result.first;   expect( entry[ :data ]             ).to     have_key( :payload )
-      entry = outbound.first; expect( entry[ :data ][ :payload ] ).to     have_key( :response_body )
-    end
+          inbound, result, outbound = get_data_for( :show )
+          data = result.first[ :data ]
 
-    # To test_log, 'update' says secure for 'request'
-    #
-    it 'does not log update responses unexpectedly' do
-      patch '/v1/test_log/foo', '{ "foo": "bar" }', { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+          expect( data[ :session ][ 'session_id'           ] ).to be_present
+          expect( data[ :session ][ 'caller_id'            ] ).to be_present
+          expect( data[ :session ][ 'caller_version'       ] ).to be_present
+          expect( data[ :session ][ 'caller_identity_name' ] ).to be_present
+          expect( data[ :session ][ 'identity'             ] ).to be_present
 
-      inbound, result, outbound = get_data_for( :update )
-      check_common_entries( 'TestLog', 1, 'update', inbound.last, result.first, outbound.first )
+          expect( data[ :session ][ 'permissions' ] ).to_not be_present
+          expect( data[ :session ][ 'scoping'     ] ).to_not be_present
+        end
+      end
 
-      entry = inbound.last;   expect( entry[ :data ][ :payload ] ).to     have_key( :body )
-      entry = result.first;   expect( entry[ :data ]             ).to_not have_key( :payload )
-      entry = outbound.first; expect( entry[ :data ][ :payload ] ).to_not have_key( :response_body )
-    end
+      context 'which is turned on' do
+        before :each do
+          @old_verbose = Hoodoo::Services::Middleware.verbose_logging?
+          Hoodoo::Services::Middleware.set_verbose_logging( true )
+        end
 
-    # To test_log_b, 'create' says secure for 'both'.
-    #
-    it 'does not log requests or responses unexpectedly' do
-      post '/v2/test_log_b', '{ "foo": "bar" }', { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+        after :each do
+          Hoodoo::Services::Middleware.set_verbose_logging( @old_verbose )
+        end
+
+        it 'and includes non-identity information in the session section' do
+          get '/v1/test_log/hello', nil, { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
 
-      inbound, result, outbound = get_data_for( :create )
-      check_common_entries( 'TestLogB', 2, 'create', inbound.last, result.first, outbound.first )
+          inbound, result, outbound = get_data_for( :show )
+          data = result.first[ :data ]
 
-      entry = inbound.last;   expect( entry[ :data ][ :payload ] ).to_not have_key( :body )
-      entry = result.first;   expect( entry[ :data ]             ).to_not have_key( :payload )
-      entry = outbound.first; expect( entry[ :data ][ :payload ] ).to_not have_key( :response_body )
+          expect( data[ :session ][ 'session_id'           ] ).to be_present
+          expect( data[ :session ][ 'caller_id'            ] ).to be_present
+          expect( data[ :session ][ 'caller_version'       ] ).to be_present
+          expect( data[ :session ][ 'caller_identity_name' ] ).to be_present
+          expect( data[ :session ][ 'identity'             ] ).to be_present
+          expect( data[ :session ][ 'permissions'          ] ).to be_present
+          expect( data[ :session ][ 'scoping'              ] ).to be_present
+        end
+      end
     end
 
-    # To test_log_b, 'update' does not ask for security.
-    #
-    it 'does not log requests or responses unexpectedly' do
-      patch '/v2/test_log_b/foo', '{ "foo": "bar" }', { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+    context 'secure logging' do
 
-      inbound, result, outbound = get_data_for( :update )
-      check_common_entries( 'TestLogB', 2, 'update', inbound.last, result.first, outbound.first )
+      # To test_log, 'create' says secure for 'request'
+      #
+      it 'does not log creation requests unexpectedly' do
+        post '/v1/test_log', '{ "foo": "bar" }', { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
 
-      entry = inbound.last;   expect( entry[ :data ][ :payload ] ).to have_key( :body )
-      entry = result.first;   expect( entry[ :data ]             ).to have_key( :payload )
-      entry = outbound.first; expect( entry[ :data ][ :payload ] ).to have_key( :response_body )
+        inbound, result, outbound = get_data_for( :create )
+        check_common_entries( 'TestLog', 1, 'create', inbound.last, result.first, outbound.first )
+
+        entry = inbound.last;   expect( entry[ :data ][ :payload ] ).to_not have_key( :body )
+        entry = result.first;   expect( entry[ :data ]             ).to     have_key( :payload )
+        entry = outbound.first; expect( entry[ :data ][ :payload ] ).to     have_key( :response_body )
+      end
+
+      # To test_log, 'update' says secure for 'request'
+      #
+      it 'does not log update responses unexpectedly' do
+        patch '/v1/test_log/foo', '{ "foo": "bar" }', { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+
+        inbound, result, outbound = get_data_for( :update )
+        check_common_entries( 'TestLog', 1, 'update', inbound.last, result.first, outbound.first )
+
+        entry = inbound.last;   expect( entry[ :data ][ :payload ] ).to     have_key( :body )
+        entry = result.first;   expect( entry[ :data ]             ).to_not have_key( :payload )
+        entry = outbound.first; expect( entry[ :data ][ :payload ] ).to_not have_key( :response_body )
+      end
+
+      # To test_log_b, 'create' says secure for 'both'.
+      #
+      it 'does not log requests or responses unexpectedly' do
+        post '/v2/test_log_b', '{ "foo": "bar" }', { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+
+        inbound, result, outbound = get_data_for( :create )
+        check_common_entries( 'TestLogB', 2, 'create', inbound.last, result.first, outbound.first )
+
+        entry = inbound.last;   expect( entry[ :data ][ :payload ] ).to_not have_key( :body )
+        entry = result.first;   expect( entry[ :data ]             ).to_not have_key( :payload )
+        entry = outbound.first; expect( entry[ :data ][ :payload ] ).to_not have_key( :response_body )
+      end
+
+      # To test_log_b, 'update' does not ask for security.
+      #
+      it 'does not log requests or responses unexpectedly' do
+        patch '/v2/test_log_b/foo', '{ "foo": "bar" }', { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+
+        inbound, result, outbound = get_data_for( :update )
+        check_common_entries( 'TestLogB', 2, 'update', inbound.last, result.first, outbound.first )
+
+        entry = inbound.last;   expect( entry[ :data ][ :payload ] ).to have_key( :body )
+        entry = result.first;   expect( entry[ :data ]             ).to have_key( :payload )
+        entry = outbound.first; expect( entry[ :data ][ :payload ] ).to have_key( :response_body )
+      end
     end
   end
 end

data/spec/services/services/session_spec.rb

@@ -293,7 +293,13 @@ describe Hoodoo::Services::Session do
       raise 'Mock Memcached connection failure'
     end
 
-    expect( Hoodoo::Services::Middleware.logger ).to receive( :warn ).once.and_call_original
+    expect( Hoodoo::Services::Middleware.logger ).to(
+      receive( :warn ).once.with(
+        'Hoodoo::Services::Session\\#load_from_memcached!: Session loading failed - connection fault or session corrupt',
+        'Mock Memcached connection failure'
+      ).and_call_original
+    )
+
     expect( loader.load_from_memcached!( '1234' ) ).to eq( :fail )
   end
 
@@ -303,11 +309,20 @@ describe Hoodoo::Services::Session do
       :caller_version => 1
     )
 
+    # The first 'set' call is an attempt to update the caller version before
+    # the updated session is saved.
+
     expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :set ).once do
       raise 'Mock Memcached connection failure'
     end
 
-    expect( Hoodoo::Services::Middleware.logger ).to receive( :warn ).once.and_call_original
+    expect( Hoodoo::Services::Middleware.logger ).to(
+      receive( :warn ).once.with(
+        'Hoodoo::Services::Session\\#update_caller_version_in_memcached: Client version update - connection fault or corrupt record',
+        'Mock Memcached connection failure'
+      ).and_call_original
+    )
+
     expect( s.save_to_memcached() ).to eq( :fail )
   end
 
@@ -322,7 +337,13 @@ describe Hoodoo::Services::Session do
       raise 'Mock Memcached connection failure'
     end
 
-    expect( Hoodoo::Services::Middleware.logger ).to receive( :warn ).once.and_call_original
+    expect( Hoodoo::Services::Middleware.logger ).to(
+      receive( :warn ).once.with(
+        'Hoodoo::Services::Session\\#save_to_memcached: Session saving failed - connection fault or session corrupt',
+        'Mock Memcached connection failure'
+      ).and_call_original
+    )
+
     expect( s.save_to_memcached() ).to eq( :fail )
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoodoo
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - Loyalty New Zealand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-18 00:00:00.000000000 Z
+date: 2016-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio