                        "Missing earliest-time among"
                        (keys outgoing)))
         label ::check-for-previous-block-to-resend
-        log-state (log2/debug log-state
-                              label
-                              "Checking for a block to resend")]
+        log-state (log/debug log-state
+                             label
+                             "Checking for a block to resend")]
     (if (and (< 0 (count un-ackd-blocks))
              (>= recent (+ earliest-time n-sec-per-block))
              (>= recent (+ earliest-time rtt-timeout)))
-      (let [log-state (log2/debug log-state
-                                  label
-                                  "It has been long enough to justify resending one of our un-ACK'd blocks"
-                                  {::specs/message-loop-name message-loop-name
-                                   ::un-ackd-block-count (count un-ackd-blocks)})]
+      (let [log-state (log/debug log-state
+                                 label
+                                 "It has been long enough to justify resending one of our un-ACK'd blocks"
+                                 {::specs/message-loop-name message-loop-name
+                                  ::un-ackd-block-count (count un-ackd-blocks)})]
         ;; This gets us to line 344
         ;; It finds the first block that matches earliest-time
         ;; It's going to re-send that block (it *does* exist...right?)

             ;; We haven't had another timeout since the last-panic.
             ;; Don't adjust those dials.
             state')
           ::log2/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})))))

(declare send-eof-buffered?)
(s/fdef ok-to-send-new?
        :args (s/cat :state ::specs/state)
        :ret (s/keys :req [::ok-send? ::log2/state]))
(defn ok-to-send-new?
  [{:keys [::specs/message-loop-name
           ::specs/recent]

                                  ::specs/send-buf buf
                                  ::specs/want-ping ::specs/false)))
          result (assoc result
                        ::log/state
                        (log/debug log-state
                                   label
                                   "Next block built and control state updated to"
                                   {::log/state result}))]
      ;; It's tempting to split this part up to avoid the conditional.
      ;; Maybe turn the call into a multimethod.
      ;; The latter would be a mistake, since there are
