                         ;; instead.
                         ;; That destroys functional purity, so is not
                         ;; an option.
-                        (log/info (utils/pre-log message-loop-name)
-                                  (str size
-                                       " bytes in "
-                                       send-buf
-                                       " forwarded to parent, triggered by\n"
-                                       triggerer
-                                       succeeded)))
+                        (log2/flush-logs! logger
+                                          (log2/info internal-log-state
+                                                     ::succeeded
+                                                     "Forwarded"
+                                                     {::buffer-size size
+                                                      ::specs/send-buf send-buf
+                                                      ::send-from triggerer
+                                                      ::success succeeded})))
                       (fn [failed]
-                        (log/error failed
-                                   (utils/pre-log message-loop-name)
-                                   (str "Failed to forward "
-                                        size
-                                        " bytes in "
-                                        send-buf
-                                        " to parent.\n"
-                                        "Probably don't care.\n"
-                                        "Triggered by\n"
-                                        triggerer))))))
+                        (log2/flush-logs! logger
+                                          (log2/error internal-log-state
+                                                      ::failed
+                                                      ;; This will trigger again, won't
+                                                      ;; it? (i.e. we'll keep trying to
+                                                      ;; send until we get an ACK)
+                                                      "Forwarding. Q: Do we care?"
+                                                      {::buffer-size size
+                                                       ::specs/send-buf send-buf
+                                                       ::send-from triggerer
+                                                       ::failure failed}))))
+    caller-log-state))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Public

              ::specs/error K/eof-error))))

(s/fdef build-message-block-description
        :args (s/cat :message-loop-name ::specs/message-loop-name
                     :block-description ::specs/block)
        :ret bytes?)
(defn build-message-block-description
  ^ByteBuf [message-loop-name
            {^Long start-pos ::specs/start-pos
             ^Integer next-message-id ::specs/message-id
             ;; TODO: Switch this to either a bytes or a clojure
             ;; vector of bytes.
             ;; Then again...the bit about tracking the current
             ;; read position seems pretty worthwhile.
             ^ByteBuf buf ::specs/buf
             :as block-to-send}]
  ;;; Lines 387-402

  ;; Note that we're messing around with mutable data.

      (check-for-new-block-to-send found?))))

(s/fdef block->parent!
        :args (s/cat :logger ::log2/logger
                     :log-state ::log2/state
                     :->parent ::specs/->parent
                     :send-buf ::specs/buf)
        :ret ::log2/state)
(defn block->parent!
  "Actually send the message block to the parent"
  ;; Corresponds to line 404 under the sendblock: label
  [message-loop-name
   logger
   log-state
   ->parent
   ^bytes send-buf]
  {:pre [send-buf]}
