                               ;; much more robust because of them.
                               ;; FIXME: Revisit this soon.
                               logs (if (= 3 new-state)
-                                     (let [logs (log2/info logs
-                                                           ::echo-parent-cb
-                                                           "Echo sent. Pretending other child triggers done")
+                                     (let [logs (log/info logs
+                                                          ::echo-parent-cb
+                                                          "Echo sent. Pretending other child triggers done")
                                            ;; This seems like a good time for the parent
                                            ;; to send EOF
                                            io-handle @io-handle-atom]

                                (if (keyword? incoming)
                                  (do
                                    (swap! log-atom
                                           #(log2/warn %
                                                       ::server-child-cb
                                                       "Received EOF"
                                                       incoming))
                                    (is (s/valid? ::specs/eof-flag incoming))
                                    (message/child-close! @client-io-atom))
                                  (swap! log-atom
                                         #(log2/debug %
                                                      ::server-child-cb
                                                      "Received message bytes"
                                                      (-> response-state
                                                          (dissoc :buffer)
                                                          (assoc :buffer-size (count (:buffer response-state)))
                                                          (assoc ::packet-size packet-size)))))
                                (swap! srvr-child-state
                                       (fn [cur]
                                         (swap! log-atom
                                                #(log2/info %
                                                            ::server-child-cb
                                                            "Incrementing state count"))
                                         (let [incoming (if (keyword? incoming)
                                                          [incoming]
                                                          incoming)]

                             ;; up and then sends them
                             ;; all at once
                             (swap! log-atom
                                    log/info
                                    ::server-parent-cb
                                    (str "Message from server to client."
                                         "\nThis really should just be an ACK"))
