               ;; gibberish messages
               (let [wrote (dfrd/future
                             (let [logs @log-atom
-                                  logs (log2/debug logs
-                                                   ::echo-initial-write
-                                                   "Writing message from parent")]
+                                  logs (log/debug logs
+                                                  ::echo-initial-write
+                                                  "Writing message from parent")]
                               (message/parent->! io-handle incoming)
-                              (let [logs (log2/debug logs
-                                                     ::echo-initial-write
-                                                     "Message should be headed to child")
-                                    logs (log2/flush-logs! logger logs)]
+                              (let [logs (log/debug logs
+                                                    ::echo-initial-write
+                                                    "Message should be headed to child")
+                                    logs (log/flush-logs! logger logs)]
                                 (reset! log-atom logs))))
                     ;; The time delay here is pretty crazy.
                     ;; It seems as though it should never take human-noticeable time.

                        ;; might do.
                        (is (s/valid? bytes? buf))
                        (let [response-state @parent-state
                              logs (log2/debug @log-atom
                                               ::echo-parent-cb
                                               "Top of callback"
                                               {::response-state response-state
                                                ::called-from (utils/get-stack-trace (Exception.))})
                              new-state (swap! parent-state inc)
                              ;; I'd like to get 3 message packets here:
                              ;; 1. ACK

    (is (= msg-len K/k-1))
    (.writeBytes src message-body)
    (let [{incoming ::specs/bs-or-eof
           log-state ::log/state} (to-parent/build-message-block-description @log-atom
                                                                             {::specs/buf src
                                                                              ::specs/length msg-len
                                                                              ::specs/message-id message-id
                                                                              ::specs/send-eof ::specs/false
                                                                              ::specs/start-pos 0})]
      (reset! log-atom log-state)
      (is (= K/max-msg-len (count incoming)))
      (let [response (dfrd/deferred)
