Fix validation of extracted exception fields.

docs/source/news.rst

@@ -1,6 +1,13 @@
 What's New
 ==========
 
+0.10.1
+^^^^^^
+
+Bug fixes:
+
+* Fixed regression in 0.10.0: fix validation of failed actions and tracebacks with extracted additional fields.
+
 0.10.0
 ^^^^^^
 

eliot/_traceback.py

@@ -17,8 +17,6 @@
 from ._validation import MessageType, Field
 from ._errors import _error_extraction
 
-# The fields here are actually subset of what you might get in practice,
-# due to exception extraction, so don't rely on this for validation.
 TRACEBACK_MESSAGE = MessageType(
     "eliot:traceback",
     [Field(REASON_FIELD, safeunicode, "The exception's value."),
@@ -27,7 +25,9 @@
            lambda typ: "%s.%s" % (typ.__module__, typ.__name__),
            "The exception type's FQPN.")],
     "An unexpected exception indicating a bug.")
-
+# The fields here are actually subset of what you might get in practice,
+# due to exception extraction, so we hackily modify the serializer:
+TRACEBACK_MESSAGE._serializer.allow_additional_fields = True
 
 
 def _writeTracebackMessage(logger, typ, exception, traceback):

eliot/_validation.py

@@ -205,8 +205,10 @@ class _MessageSerializer(object):
 
     @ivar fields: A C{dict} mapping a C{unicode} field name to the respective
         L{Field}.
+    @ivar allow_additional_fields: If true, additional fields don't cause
+        validation failure.
     """
-    def __init__(self, fields):
+    def __init__(self, fields, allow_additional_fields=False):
         keys = []
         for field in fields:
             if not isinstance(field, Field):
@@ -229,7 +231,7 @@ def __init__(self, fields):
                 raise ValueError(keys, "The field name %r is reserved for use "
                                  "by the logging framework" % (reserved,))
         self.fields = dict((field.key, field) for field in fields)
-
+        self.allow_additional_fields = allow_additional_fields
 
     def serialize(self, message):
         """
@@ -260,6 +262,10 @@ def validate(self, message):
             if key not in message:
                 raise ValidationError(message, "Field %r is missing" % (key,))
             field.validate(message[key])
+
+        if self.allow_additional_fields:
+            return
+        # Otherwise, additional fields are not allowed:
         fieldSet = set(self.fields) | set(RESERVED_FIELDS)
         for key in message:
             if key not in fieldSet:
@@ -397,9 +403,13 @@ def makeActionStatusField(value):
             actionTypeField, makeActionStatusField(FAILED_STATUS), REASON,
             EXCEPTION]
 
-        self._serializers = _ActionSerializers(_MessageSerializer(startFields),
-                                               _MessageSerializer(successFields),
-                                               _MessageSerializer(failureFields))
+        self._serializers = _ActionSerializers(
+            _MessageSerializer(startFields),
+            _MessageSerializer(successFields),
+            # Failed action messages can have extra fields from exception
+            # extraction:
+            _MessageSerializer(failureFields,
+                               allow_additional_fields=True))
 
 
     def __call__(self, logger=None, **fields):

eliot/tests/test_action.py

@@ -1353,14 +1353,16 @@ def get_failed_action_messages(exception):
 
     :return: Logged dictionaries from the exception failing an action.
     """
+    action_type = ActionType("sys:me", [], [])
     logger = MemoryLogger()
-    action = Action(logger, "uuid", TaskLevel(level=[1]), "sys:me")
+    action = action_type.as_task(logger=logger)
     try:
         with action:
             raise exception
     except exception.__class__:
         pass
-    return logger.messages
+    logger.validate()
+    return logger.messages[1:]
 
 
 class FailedActionExtractionTests(make_error_extraction_tests(
@@ -1381,8 +1383,7 @@ class MyException(Exception):
         exception = MyException("because")
         messages = get_failed_action_messages(exception)
         assertContainsFields(self, messages[0],
-                             {"task_uuid": "uuid",
-                              "task_level": [1, 1],
+                             {"task_level": [2],
                               "action_type": "sys:me",
                               "action_status": "failed",
                               "reason": "because",

eliot/tests/test_traceback.py

@@ -213,7 +213,11 @@ def get_traceback_messages(exception):
         raise exception
     except exception.__class__:
         writeTraceback(logger)
-    return logger.messages
+    # MemoryLogger.validate() mutates messages:
+    # https://github.com/ClusterHQ/eliot/issues/243
+    messages = [message.copy() for message in logger.messages]
+    logger.validate()
+    return messages
 
 
 class TracebackExtractionTests(

eliot/tests/test_validation.py

@@ -669,7 +669,6 @@ def getSerializer(self, actionType):
         return actionType._serializers.start
 
 
-
 class ActionTypeSuccessMessage(TestCase, ActionTypeTestsMixin):
     """
     Tests for L{ActionType} validation of action success messages.
@@ -702,10 +701,20 @@ def getValidMessage(self):
                 "reason": "because",
                 }
 
-
     def getSerializer(self, actionType):
         return actionType._serializers.failure
 
+    def test_validateExtraField(self):
+        """
+        Additional fields (which can be added by exception extraction) don't
+        cause a validation failure for failed action messages.
+        """
+        actionType = self.actionType()
+        message = self.getValidMessage()
+        message.update(
+             {"task_level": "/", "task_uuid": "123", "timestamp": "xxx"})
+        message.update({"extra_field": "hello"})
+        self.getSerializer(actionType).validate(message)
 
 
 class ChildActionTypeStartMessage(TestCase):