              ;; We haven't had another timeout since the last-panic.
              ;; Don't adjust those dials.
              state')
-           ::log2/state log-state)))
+           ::log/state log-state)))
       ;; Honestly, it makes more sense to consolidate the
       ;; gap-buffer with any ACKs in this message before
       ;; looking for messages to resend.
       ;; TODO: That instead.
       (update state
-              ::log2/state
-              #(log2/debug %
-                           label
-                           "Conditions wrong for resending any of our previously sent un-ack'd blocks"
-                           {::un-ackd-count (count un-ackd-blocks)
-                            ::specs/earliest-time earliest-time
-                            ::specs/n-sec-per-block n-sec-per-block
-                            ::specs/rtt-timeout (long rtt-timeout)
-                            ::specs/recent recent})))))
+              ::log/state
+              #(log/debug %
+                          label
+                          "Conditions wrong for resending any of our previously sent un-ack'd blocks"
+                          {::un-ackd-count (count un-ackd-blocks)
+                           ::specs/earliest-time earliest-time
+                           ::specs/n-sec-per-block n-sec-per-block
+                           ::specs/rtt-timeout (long rtt-timeout)
+                           ::specs/recent recent})))))
 
 (declare send-eof-buffered?)
 (s/fdef ok-to-send-new?
         :args (s/cat :state ::specs/state)
-        :ret (s/keys :req [::ok-send? ::log2/state]))
+        :ret (s/keys :req [::ok-send? ::log/state]))
 (defn ok-to-send-new?
   [{:keys [::specs/message-loop-name
            ::specs/recent]

          ;; TODO: Lots of research to make sure I do this correctly.
          ;; (The obvious downside is increased bandwidth)
          (update state
                  ::log2/state
                  #(log2/debug %
                               label
                               "Nothing to send"))))
      (catch Exception ex
        (println "OK, that failed:\n" ex)
        (update state
                ::log2/state
                #(log2/exception %
                                 ex
                                 label
                                 "Trying to send message block to parent"))))))

(s/fdef send-eof-buffered?
        :args (s/cat :outgoing ::specs/outgoing)

                        ;; instead.
                        ;; That destroys functional purity, so is not
                        ;; an option.
                        (log/flush-logs! logger
                                         (log/info internal-log-state
                                                   ::succeeded
                                                   "Forwarded"
                                                   {::buffer-size size
                                                    ::specs/send-buf send-buf
                                                    ::send-from triggerer
                                                    ::success succeeded})))
                      (fn [failed]
                        (log/flush-logs! logger
                                         (log/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))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
