Remove logging topics (#137)

* Remove logging topics

* Pin Kondo version

* Work around clj-kondo/clj-kondo#2026

* Cloverage: ignore namespaces we don't test in Cloverage

Author: camsaul

deps.edn

@@ -121,7 +121,12 @@
                  toucan2.log/warnf]
 
                 :ns-regex
-                ["^toucan\\..*" "^toucan2\\..*"]}}
+                ["^toucan\\..*" "^toucan2\\..*"]
+
+                ;; ignore namespaces we don't test with Cloverage.
+                :ns-exclude-regex
+                ["^toucan2\\.query-execution-backend\\.jdbc\\.mysql-mariadb.*"
+                 "^toucan2\\.query-execution-backend\\.jdbc\\.postgres.*"]}}
 
   ;; clojure -T:build
   :build

scripts/lint-and-test-fast.sh

@@ -4,6 +4,8 @@
 
 set -euxo pipefail
 
+codespell
+
 clj-kondo --parallel --lint src test toucan1/src/ toucan1/test/
 
 clojure -X:dev:test:test-h2 $@

scripts/lint-and-test.sh

@@ -10,4 +10,6 @@ set -euxo pipefail
 
 codespell
 
+clj-kondo --parallel --lint src test toucan1/src/ toucan1/test/
+
 clojure -X:dev:test $@

src/toucan2/connection.clj

@@ -113,7 +113,7 @@
   (let [connectable-class (if (instance? pretty.core.PrettyPrintable connectable)
                             (pretty/pretty connectable)
                             (protocols/dispatch-value connectable))]
-    (log/debugf :execute "Resolve connection %s" connectable-class)
+    (log/debugf "Resolve connection %s" connectable-class)
     (u/try-with-error-context ["resolve connection" {::connectable connectable-class}]
       (next-method connectable (bind-current-connectable-fn f)))))
 
@@ -264,14 +264,14 @@
 (m/defmethod do-with-transaction :around ::default
   "Bind [[*current-connectable*]] to the connection `f` is called with inside of `f`."
   [connection options f]
-  (log/debugf :execute "do with transaction %s %s" options (some-> connection class .getCanonicalName symbol))
+  (log/debugf "do with transaction %s %s" options (some-> connection class .getCanonicalName symbol))
   (next-method connection options (bind-current-connectable-fn f)))
 
 (m/defmethod do-with-transaction java.sql.Connection
   [^java.sql.Connection conn options f]
   (let [nested-tx-rule (get options :nested-transaction-rule :allow)
         options        (dissoc options :nested-transaction-rule)]
-    (log/debugf :execute "do with JDBC transaction (nested rule: %s) with options %s" nested-tx-rule options)
+    (log/debugf "do with JDBC transaction (nested rule: %s) with options %s" nested-tx-rule options)
     (binding [next.jdbc.transaction/*nested-tx* nested-tx-rule]
       (next.jdbc/with-transaction [t-conn conn options]
         (f t-conn)))))

src/toucan2/insert.clj

@@ -65,10 +65,10 @@
   (let [rows (some (comp not-empty :rows) [parsed-args resolved-query])]
     (if (can-skip-insert? parsed-args resolved-query)
       (do
-        (log/debugf :compile "Query has no changes, skipping update")
+        (log/debugf "Query has no changes, skipping update")
         ::pipeline/no-op)
       (do
-        (log/debugf :compile "Inserting %s rows into %s" (if (seq rows) (count rows) "?") model)
+        (log/debugf "Inserting %s rows into %s" (if (seq rows) (count rows) "?") model)
         (next-method query-type model parsed-args resolved-query)))))
 
 (defn insert!

src/toucan2/jdbc/query.clj

@@ -28,29 +28,29 @@
         opts (merge (when-not (:return-keys opts)
                       read-forward-options)
                     opts)]
-    (log/debugf :execute "Preparing JDBC query with next.jdbc options %s" opts)
+    (log/debugf "Preparing JDBC query with next.jdbc options %s" opts)
     (u/try-with-error-context [(format "execute SQL with %s" (class conn)) {::sql-args sql-args}]
       (with-open [stmt (next.jdbc/prepare conn sql-args opts)]
         (when-not (= (.getFetchDirection stmt) ResultSet/FETCH_FORWARD)
           (try
             (.setFetchDirection stmt ResultSet/FETCH_FORWARD)
             (catch Throwable e
-              (log/debugf :results e "Error setting fetch direction"))))
-        (log/tracef :execute "Executing statement with %s" (class conn))
+              (log/debugf e "Error setting fetch direction"))))
+        (log/tracef "Executing statement with %s" (class conn))
         (let [result-set? (.execute stmt)]
           (cond
             (:return-keys opts)
             (do
-              (log/debugf :execute "Query was executed with %s; returning generated keys" :return-keys)
+              (log/debugf "Query was executed with %s; returning generated keys" :return-keys)
               (with-open [rset (.getGeneratedKeys stmt)]
                 (jdbc.rs/reduce-result-set rf init conn model rset opts)))
 
             result-set?
             (with-open [rset (.getResultSet stmt)]
-              (log/debugf :execute "Query returned normal result set")
+              (log/debugf "Query returned normal result set")
               (jdbc.rs/reduce-result-set rf init conn model rset opts))
 
             :else
             (do
-              (log/debugf :execute "Query did not return a ResultSet; nothing to reduce. Returning update count.")
+              (log/debugf "Query did not return a ResultSet; nothing to reduce. Returning update count.")
               (reduce rf init [(.getUpdateCount stmt)]))))))))

src/toucan2/jdbc/read.clj

@@ -43,7 +43,7 @@
   {:arglists '([^Connection conn₁ model₂ ^ResultSet rset ^ResultSetMetaData rsmeta₍₃₎ ^Long i])}
   (fn [^Connection conn model _rset ^ResultSetMetaData rsmeta ^Long i]
     (let [col-type (.getColumnType rsmeta i)]
-      (log/debugf :results
+      (log/debugf
                   "Column %s %s is of JDBC type %s, native type %s"
                   i
                   (let [table-name (some->> (.getTableName rsmeta i) not-empty)
@@ -57,9 +57,9 @@
 
 (m/defmethod read-column-thunk :default
   [_conn _model ^ResultSet rset _rsmeta ^Long i]
-  (log/debugf :results "Fetching values in column %s with %s" i (list '.getObject 'rs i))
+  (log/debugf "Fetching values in column %s with %s" i (list '.getObject 'rs i))
   (fn default-read-column-thunk []
-    (log/tracef :results "col %s => %s" i (list '.getObject 'rset i))
+    (log/tracef "col %s => %s" i (list '.getObject 'rset i))
     (.getObject rset i)))
 
 (m/defmethod read-column-thunk :after :default
@@ -78,7 +78,7 @@
 
   but includes extra logging."
   [^ResultSet rset ^Long i ^Class klass]
-  (log/debugf :results
+  (log/debugf
               "Fetching values in column %s with %s"
               i
               (list '.getObject 'rs i klass))
@@ -88,7 +88,7 @@
     ;; from Criterium: a no-op call takes about 20ns locally. So 10m rows => 200ms from this no-op call. That's a little
     ;; expensive, but probably not as bad as the overhead we get from other nonsense here in Toucan 2. We'll have to do
     ;; some general performance tuning in the future.
-    (log/tracef :results "col %s => %s" i (list '.getObject 'rset i klass))
+    (log/tracef "col %s => %s" i (list '.getObject 'rset i klass))
     (.getObject rset i klass)))
 
 ;;;; Default column read methods
@@ -119,7 +119,7 @@
   (get-object-of-class-thunk rset i java.time.OffsetTime))
 
 (defn- make-column-thunk [conn model ^ResultSet rset i]
-  (log/tracef :results "Building thunk to read column %s" i)
+  (log/tracef "Building thunk to read column %s" i)
   (fn column-thunk []
     (let [rsmeta (.getMetaData rset)
           thunk  (read-column-thunk conn model rset rsmeta i)
@@ -164,7 +164,7 @@
         (fn cached-column-thunk []
           (let [cached-value (get @cached-values i ::not-found)]
             (if-not (= cached-value ::not-found)
-              (log/tracef :results "Using cached value for column %s: %s" i cached-value)
+              (log/tracef "Using cached value for column %s: %s" i cached-value)
               cached-value)
             (let [thunk (i->thunk i)
                   v     (thunk)]
@@ -197,5 +197,5 @@
      (let [i->thunk (row-num->i->thunk (.getRow rset))
            thunk    (i->thunk i)
            result   (thunk)]
-       (log/tracef :results "col %s => %s" i result)
+       (log/tracef "col %s => %s" i result)
        result))))

src/toucan2/jdbc/result_set.clj

@@ -37,7 +37,7 @@
 (defrecord ^:no-doc InstanceBuilder [model ^ResultSet rset ^ResultSetMetaData rsmeta cols]
   next.jdbc.rs/RowBuilder
   (->row [_this]
-    (log/tracef :results "Fetching row %s" (.getRow rset))
+    (log/tracef "Fetching row %s" (.getRow rset))
     (transient (instance/instance model)))
 
   (column-count [_this]
@@ -55,7 +55,7 @@
     (assoc! row col v))
 
   (row! [_this row]
-    (log/tracef :results "Converting transient row to persistent row")
+    (log/tracef "Converting transient row to persistent row")
     (persistent! row))
 
   next.jdbc.rs/ResultSetBuilder
@@ -89,9 +89,9 @@
                                         (when (= col column-name')
                                           (inc i)))
                                       cols)))]
-           (log/tracef :results "Index of column named %s (originally %s) is %s" column-name' column-name i)
+           (log/tracef "Index of column named %s (originally %s) is %s" column-name' column-name i)
            (when-not i
-             (log/debugf :results "Could not determine index of column name %s. Found: %s" column-name cols))
+             (log/debugf "Could not determine index of column name %s. Found: %s" column-name cols))
            i))))))
 
 (defn instance-builder-fn
@@ -105,15 +105,15 @@
                         (fn [table]
                           (let [table    (some-> table not-empty name label-fn)
                                 table-ns (some-> (get table-name->ns table) name)]
-                            (log/tracef :results "Using namespace %s for columns in table %s" table-ns table)
+                            (log/tracef "Using namespace %s for columns in table %s" table-ns table)
                             table-ns)))
         opts           (merge {:label-fn     label-fn
                                :qualifier-fn qualifier-fn}
                               opts)
         rsmeta         (.getMetaData rset)
-        _              (log/debugf :results "Getting modified column names with next.jdbc options %s" opts)
+        _              (log/debugf "Getting modified column names with next.jdbc options %s" opts)
         col-names      (next.jdbc.rs/get-modified-column-names rsmeta opts)]
-    (log/debugf :results "Column names: %s" col-names)
+    (log/debugf "Column names: %s" col-names)
     (constantly
      (assoc (->InstanceBuilder model rset rsmeta col-names) :opts opts))))
 
@@ -131,7 +131,7 @@
   Part of the low-level implementation of the JDBC query execution backend -- you probably shouldn't be using this
   directly."
   [rf init conn model ^ResultSet rset opts]
-  (log/debugf :execute "Reduce JDBC result set for model %s with rf %s and init %s" model rf init)
+  (log/debugf "Reduce JDBC result set for model %s with rf %s and init %s" model rf init)
   (let [row-num->i->thunk (jdbc.read/make-cached-row-num->i->thunk conn model rset)
         builder-fn*       (next.jdbc.rs/builder-adapter
                            (builder-fn conn model rset opts)
@@ -144,16 +144,16 @@
                                               (.getMetaData rset)
                                               combined-opts))
         col-name->index   (make-column-name->index col-names label-fn)]
-    (log/tracef :results "column name -> index = %s" col-name->index)
+    (log/tracef "column name -> index = %s" col-name->index)
     (loop [acc init]
       (b/cond
         (not (.next rset))
         (do
-          (log/tracef :results "Result set has no more rows.")
+          (log/tracef "Result set has no more rows.")
           acc)
 
         :let [row-num  (.getRow rset)
-              _        (log/tracef :results "Fetch row %s" row-num)
+              _        (log/tracef "Fetch row %s" row-num)
               i->thunk (row-num->i->thunk row-num)
               row      (jdbc.row/row model rset builder i->thunk col-name->index)
               acc'     (rf acc row)]

src/toucan2/jdbc/row.clj

@@ -34,7 +34,7 @@
                  :let        [thunk (i->thunk i)]
                  (not thunk) not-found
                  :else       (thunk))]
-    (log/tracef :results "=> %s" result)
+    (log/tracef "=> %s" result)
     result))
 
 (def ^:private ^:dynamic *fetch-all-columns* true)
@@ -71,7 +71,7 @@
 
   clojure.lang.IPersistentMap
   (assoc [this k v]
-    (log/tracef :results ".assoc %s %s" k v)
+    (log/tracef ".assoc %s %s" k v)
     (if @already-realized?
       (assoc @realized-row k v)
       (let [^clojure.lang.ITransientMap transient-row' (assoc! transient-row k v)]
@@ -99,11 +99,11 @@
 
   ;; TODO -- can we `assocEx` the transient row?
   (assocEx [_this k v]
-    (log/tracef :results ".assocEx %s %s" k v)
+    (log/tracef ".assocEx %s %s" k v)
     (.assocEx ^clojure.lang.IPersistentMap @realized-row k v))
 
   (without [this k]
-    (log/tracef :results ".without %s" k)
+    (log/tracef ".without %s" k)
     (if @already-realized?
       (dissoc @realized-row k)
       (let [transient-row' (dissoc! transient-row k)]
@@ -127,31 +127,31 @@
   ;; TODO -- not sure if we need/want this
   java.lang.Iterable
   (iterator [_this]
-    (log/tracef :results ".iterator")
+    (log/tracef ".iterator")
     (.iterator ^java.lang.Iterable @realized-row))
 
   clojure.lang.Associative
   (containsKey [_this k]
-    (log/tracef :results ".containsKey %s" k)
+    (log/tracef ".containsKey %s" k)
     (boolean (column-name->index k)))
 
   (entryAt [this k]
-    (log/tracef :results ".entryAt %s" k)
+    (log/tracef ".entryAt %s" k)
     (let [v (.valAt this k ::not-found)]
       (when-not (= v ::not-found)
         (clojure.lang.MapEntry. k v))))
 
 ;;; TODO -- this should probably also include any extra keys added with `assoc` or whatever
   clojure.lang.Counted
   (count [_this]
-    (log/tracef :results ".count")
+    (log/tracef ".count")
     (let [cols (:cols builder)]
       (assert (seq cols))
       (count cols)))
 
   clojure.lang.IPersistentCollection
   (cons [this o]
-    (log/tracef :results ".cons %s" o)
+    (log/tracef ".cons %s" o)
     (cond
       (map? o)
       (reduce #(apply assoc %1 %2) this o)
@@ -165,21 +165,21 @@
         this)))
 
   (empty [_this]
-    (log/tracef :results ".empty")
+    (log/tracef ".empty")
     (instance/instance model))
 
   (equiv [_this obj]
-    (log/tracef :results ".equiv %s" obj)
+    (log/tracef ".equiv %s" obj)
     (.equiv ^clojure.lang.IPersistentCollection @realized-row obj))
 
   ;; we support get with a numeric key for array-based builders:
   clojure.lang.ILookup
   (valAt [this k]
-    (log/tracef :results ".valAt %s" k)
+    (log/tracef ".valAt %s" k)
     (.valAt this k nil))
 
   (valAt [this k not-found]
-    (log/tracef :results ".valAt %s %s" k not-found)
+    (log/tracef ".valAt %s %s" k not-found)
     (cond
       @already-realized?
       (get @realized-row k not-found)
@@ -205,26 +205,26 @@
   ;; we support nth for array-based builderset (i is primitive int here!):
   ;; clojure.lang.Indexed
   ;; (nth [_this i]
-  ;;   (log/tracef :results ".nth %s" i)
+  ;;   (log/tracef ".nth %s" i)
   ;;   (try
   ;;     (i->thunk (inc i))
   ;;     (catch java.sql.SQLException _)))
   ;; (nth [_this i not-found]
-  ;;   (log/tracef :results ".nth %s %s" i not-found)
+  ;;   (log/tracef ".nth %s %s" i not-found)
   ;;   (try
   ;;     (i->thunk (inc i))
   ;;     (catch java.sql.SQLException _
   ;;       not-found)))
 
   clojure.lang.Seqable
   (seq [_this]
-    (log/tracef :results ".seq")
+    (log/tracef ".seq")
     (seq @realized-row))
 
   ;; calling [[persistent!]] on a transient row will convert it to a persistent object WITHOUT realizing all the columns.
   clojure.lang.ITransientCollection
   (persistent [_this]
-    (log/tracef :results ".persistent")
+    (log/tracef ".persistent")
     (binding [*fetch-all-columns* false]
       @realized-row))
 
@@ -254,7 +254,7 @@
 
   protocols/IDeferrableUpdate
   (deferrable-update [this k f]
-    (log/tracef :results "Doing deferrable update of %s with %s" k f)
+    (log/tracef "Doing deferrable update of %s with %s" k f)
     (b/cond
       @already-realized?
       (update @realized-row k f)
@@ -339,15 +339,15 @@
       transient-row)))
 
 (defn- fetch-all-columns! [builder i->thunk transient-row]
-  (log/tracef :results "Fetching all columns")
+  (log/tracef "Fetching all columns")
   (reduce
    (partial fetch-column! builder i->thunk)
    transient-row
    (range 1 (inc (next.jdbc.rs/column-count builder)))))
 
 (defn- make-realized-row-delay [builder i->thunk transient-row]
   (delay
-    (log/tracef :results "Fully realizing row. *fetch-all-columns* = %s" *fetch-all-columns*)
+    (log/tracef "Fully realizing row. *fetch-all-columns* = %s" *fetch-all-columns*)
     (let [row (cond->> transient-row
                 *fetch-all-columns* (fetch-all-columns! builder i->thunk))]
       (next.jdbc.rs/row! builder row))))