                                    (:value ledger-reads)))
           all-through-intermediate? (= all-stage-2 #{2})
           unacked-writes-read (clojure.set/difference read-values added-values)]
-      {:valid? (and all-written-read? all-peers-up?)
-       :peer-log peer-log-reads
-       :final-replica final-replica
-       :added added-values
-       :read-values read-values
-       :diff-written-read diff-written-read
-       :unacknowledged-writes-read unacked-writes-read
-       :all-peers-up? all-peers-up?
-       :all-written-read? all-written-read?})))
+      (doto {:valid? (and all-written-read? all-peers-up? accepting-empty? prepared-empty? peers-match-pulses?)
+             :peers-match-pulses? peers-match-pulses?
+             :pulse-peers pulse-peers
+             :peer-log peer-log-reads
+             :accepted-empty? accepting-empty?
+             :prepared-empty? prepared-empty?
+             :final-replica final-replica
+             :added added-values
+             :job-exception-cause (some-> exception (.getCause))
+             :job-exception-trace (some-> exception (.getStackTrace))
+             :read-values read-values
+             :diff-written-read diff-written-read
+             :unacknowledged-writes-read unacked-writes-read
+             :all-peers-up? all-peers-up?
+             :all-written-read? all-written-read?}
+        info))))

                                                  (and (= (:f action) :read-peer-log)
                                                       (= (:type action) :ok)))
                                                history)))
          final-replica (reduce #(onyx.extensions/apply-log-entry %2 %1)
                                (base-replica peer-config)
                                peer-log-reads) 

          all-peers-up? (= (count (:peers final-replica))
                           (* 5 n-peers))

          results (map (fn [lr] 
                         (map :value (:results lr))) 
                       (:value ledger-reads))

          successfully-added (filter (fn [action]
                                       (and (= (:f action) :add)
                                            (= (:type action) :ok)))
                                     history)
          added-values (set (map :value successfully-added))
          read-values (set (reduce into [] results))
          diff-written-read (clojure.set/difference added-values read-values)
          all-written-read? (empty? diff-written-read)

          ;; Check that all values at the output went through the second task first
          all-stage-2 (set (mapcat (fn [lr] 

         {:job-scheduler (:onyx.peer/job-scheduler peer-config)
          :messaging (select-keys peer-config [:onyx.messaging/impl])}))

(defn playback-log [peer-config peer-log-reads]
  (reduce #(onyx.extensions/apply-log-entry %2 %1)
          (base-replica peer-config)
          peer-log-reads))

(defn pulses [conn peer-config]
  (onyx.log.curator/children conn (onyx.log.zookeeper/pulse-path (:onyx/id peer-config))))

;;; TODO, check whether the jobs were even submitted, if not, nothing should be read back
(defrecord Checker [peer-config n-peers]
  checker/Checker
  (check [checker test model history]
