[mod] Rename "interop" -> "intake"

slf4j/src/taoensso/telemere/slf4j.clj

@@ -1,6 +1,6 @@
 (ns ^:no-doc taoensso.telemere.slf4j
   "Private ns, implementation detail.
-  Interop support: SLF4J -> Telemere.
+  Intake support: SLF4J -> Telemere.
 
   To use Telemere as your SLF4J backend/provider, just include the
   `com.taoensso/slf4j-telemere` dependency on your classpath.
@@ -93,7 +93,7 @@
       (marker-names cm)
       (marker-names ms))))
 
-;;;; Interop fns (called by `TelemereLogger`)
+;;;; Intake fns (called by `TelemereLogger`)
 
 (defn allowed?
   "Private, don't use.
@@ -172,14 +172,14 @@
     (org.slf4j.MDC/getCopyOfContextMap)
     (org.slf4j.MDC/clear)))
 
-(impl/add-interop-check! :slf4j
+(impl/add-intake-check! :slf4j
   (fn []
     (let [^org.slf4j.Logger sl
-          (org.slf4j.LoggerFactory/getLogger  "InteropTestTelemereLogger")
+          (org.slf4j.LoggerFactory/getLogger  "IntakeTestTelemereLogger")
           sending? (instance? com.taoensso.telemere.slf4j.TelemereLogger sl)
           receiving?
           (and sending?
-            (impl/test-interop! "SLF4J -> Telemere" #(.info sl %)))]
+            (impl/test-intake! "SLF4J -> Telemere" #(.info sl %)))]
 
       {:present?            true
        :sending->telemere?  sending?

src/taoensso/telemere.cljc

@@ -345,11 +345,11 @@
            (handler            thread throwable))))
      nil))
 
-;;;; Interop
+;;;; Intake
 
-(enc/defaliases impl/check-interop)
 #?(:clj
    (enc/defaliases
+     impl/check-intakes
      streams/with-out->telemere
      streams/with-err->telemere
      streams/with-streams->telemere
@@ -371,11 +371,11 @@
        {:kind  :event
         :level :info
         :id    :taoensso.telemere/slf4j->telemere!
-        :msg   "Enabling interop: SLF4J -> Telemere"})
+        :msg   "Enabling intake: SLF4J -> Telemere"})
 
      (require '[taoensso.telemere.slf4j :as slf4j])))
 
-(comment (check-interop))
+(comment (check-intakes))
 
 ;;;; Handlers
 

src/taoensso/telemere/impl.cljc

@@ -671,7 +671,7 @@
 
 #?(:clj
    (defmacro signal-allowed?
-     "Used only for interop (SLF4J, `clojure.tools.logging`, etc.)."
+     "Used only for intake (SLF4J, `clojure.tools.logging`, etc.)."
      {:arglists (signal-arglists :signal!)}
      [opts]
      (let [{:keys [#_expansion-id #_location elide? allow?]}
@@ -685,30 +685,35 @@
 
        (and (not elide?) allow?))))
 
-;;;; Interop
-
-(enc/defonce ^:private interop-checks_ "{<id> (fn check [])}" (atom nil))
-(defn add-interop-check! [id check-fn] (swap! interop-checks_ assoc id check-fn))
+;;;; Intake
 
 #?(:clj
-   (when (nil? @interop-checks_)
-     (add-interop-check! :tools-logging (fn [] {:present? (enc/have-resource? "clojure/tools/logging.clj")}))
-     (add-interop-check! :slf4j         (fn [] {:present? (enc/compile-when org.slf4j.Logger true false)}))))
+   (do
+     (enc/defonce ^:private intake-checks_
+       "{<source-id> (fn check [])}"
+       (atom
+         {:tools-logging (fn [] {:present? (enc/have-resource? "clojure/tools/logging.clj")})
+          :slf4j         (fn [] {:present? (enc/compile-when org.slf4j.Logger true false)})}))
 
-(defn ^:public check-interop
-  "Experimental, subject to change.
-  Runs Telemere's registered interop checks and returns
-  {<interop-id> {:keys [sending->telemere? telemere-receiving? ...]}}.
+     (defn add-intake-check! [source-id check-fn] (swap! intake-checks_ assoc source-id check-fn))
+
+     (defn ^:public check-intakes
+       "Experimental, subject to change.
+       Runs Telemere's registered intake checks and returns
+       {<source-id> {:keys [sending->telemere? telemere-receiving? ...]}}.
+
+       Useful for tests/debugging."
+       []
+       (enc/map-vals (fn [check-fn] (check-fn))
+         @intake-checks_))
+
+     (defn test-intake! [msg test-fn]
+       (let [msg (str "Intake test: " msg " (" (enc/uuid-str) ")")
+             signal
+             (binding [*rt-sig-filter* nil] ; Without runtime filters
+               (with-signal :raw :trap (test-fn msg)))]
+
+         (= (force (get signal :msg_)) msg)))))
 
-  Useful for tests/debugging."
-  []
-  (enc/map-vals (fn [check-fn] (check-fn))
-    @interop-checks_))
 
-(defn test-interop! [msg test-fn]
-  (let [msg (str "Interop test: " msg " (" (enc/uuid-str) ")")
-        signal
-        (binding [*rt-sig-filter* nil] ; Without runtime filters
-          (with-signal :raw :trap (test-fn msg)))]
 
-    (= (force (get signal :msg_)) msg)))

src/taoensso/telemere/streams.clj

@@ -1,6 +1,6 @@
 (ns ^:no-doc taoensso.telemere.streams
   "Private ns, implementation detail.
-  Interop support: standard stream/s -> Telemere."
+  Intake support: standard stream/s -> Telemere."
   (:refer-clojure :exclude [binding])
   (:require
    [taoensso.encore        :as enc :refer [binding have have?]]
@@ -91,7 +91,7 @@
         {:kind  :event
          :level :info
          :id    :taoensso.telemere/streams->telemere!
-         :msg   "Disabling interop: standard stream/s -> Telemere"
+         :msg   "Disabling intake: standard stream/s -> Telemere"
          :data  {:system/out? (boolean orig-out)
                  :system/err? (boolean orig-err)}})
 
@@ -128,7 +128,7 @@
            {:kind  :event
             :level :info
             :id    :taoensso.telemere/streams->telemere!
-            :msg   "Enabling interop: standard stream/s -> Telemere"
+            :msg   "Enabling intake: standard stream/s -> Telemere"
             :data  {:system/out? (boolean out)
                     :system/err? (boolean err)}})
 
@@ -143,14 +143,14 @@
   (streams->telemere! {})
   (streams->reset!))
 
-(impl/add-interop-check! :system/out
+(impl/add-intake-check! :system/out
   (fn []
     (let [sending?   (boolean @orig-out_)
-          receiving? (and  sending? (impl/test-interop! "`System/out` -> Telemere" #(.println System/out %)))]
+          receiving? (and  sending? (impl/test-intake! "`System/out` -> Telemere" #(.println System/out %)))]
       {:sending->telemere? sending?, :telemere-receiving? receiving?})))
 
-(impl/add-interop-check! :system/err
+(impl/add-intake-check! :system/err
   (fn []
     (let [sending?   (boolean @orig-err_)
-          receiving? (and  sending? (impl/test-interop! "`System/err` -> Telemere" #(.println System/err %)))]
+          receiving? (and  sending? (impl/test-intake! "`System/err` -> Telemere" #(.println System/err %)))]
       {:sending->telemere? sending?, :telemere-receiving? receiving?})))

src/taoensso/telemere/tools_logging.clj

@@ -1,6 +1,6 @@
 (ns ^:no-doc taoensso.telemere.tools-logging
   "Private ns, implementation detail.
-  Interop support: `clojure.tools.logging` -> Telemere."
+  Intake support: `clojure.tools.logging` -> Telemere."
   (:require
    [taoensso.encore        :as enc :refer [have have?]]
    [taoensso.telemere.impl :as impl]
@@ -49,7 +49,7 @@
     {:kind  :event
      :level :info
      :id    :taoensso.telemere/clojure.tools.logging->telemere!
-     :msg  "Enabling interop: `clojure.tools.logging` -> Telemere"})
+     :msg   "Enabling intake: `clojure.tools.logging` -> Telemere"})
 
   (alter-var-root #'clojure.tools.logging/*logger-factory*
     (fn [_] (TelemereLoggerFactory.))))
@@ -59,12 +59,12 @@
   (when-let [lf clojure.tools.logging/*logger-factory*]
     (instance? TelemereLoggerFactory lf)))
 
-(impl/add-interop-check! :tools-logging
+(impl/add-intake-check! :tools-logging
   (fn []
     (let [sending? (tools-logging->telemere?)
           receiving?
           (and sending?
-            (impl/test-interop! "`clojure.tools.logging` -> Telemere"
+            (impl/test-intake! "`clojure.tools.logging` -> Telemere"
               #(clojure.tools.logging/info %)))]
 
       {:present?            true

test/taoensso/telemere_tests.cljc

@@ -533,35 +533,35 @@
            ;;
            (do (enc/set-var-root! impl/*sig-handlers* nil) :unset-handler)])))])
 
-;;;; Interop
+;;;; Intake
 
 (comment (def ^org.slf4j.Logger sl (org.slf4j.LoggerFactory/getLogger "MyTelemereSLF4JLogger")))
 
 #?(:clj
-   (deftest _interop
+   (deftest _intake
      [(testing "`clojure.tools.logging` -> Telemere"
-        [(is (sm? (tel/check-interop) {:tools-logging {:present? true, :sending->telemere? true, :telemere-receiving? true}}))
+        [(is (sm? (tel/check-intakes) {:tools-logging {:present? true, :sending->telemere? true, :telemere-receiving? true}}))
          (is (sm? (with-sig (ctl/info "Hello" "x" "y")) {:level :info, :location nil, :ns nil, :kind :log, :id :taoensso.telemere/tools-logging, :msg_ "Hello x y"}))
          (is (sm? (with-sig (ctl/warn "Hello" "x" "y")) {:level :warn, :location nil, :ns nil, :kind :log, :id :taoensso.telemere/tools-logging, :msg_ "Hello x y"}))
          (is (sm? (with-sig (ctl/error ex1 "An error")) {:level :error, :error pex1?}) "Errors")])
 
       (testing "Standard out/err streams -> Telemere"
-        [(is (sm?   (tel/check-interop) {:system/out {:sending->telemere? false, :telemere-receiving? false},
+        [(is (sm?   (tel/check-intakes) {:system/out {:sending->telemere? false, :telemere-receiving? false},
                                          :system/err {:sending->telemere? false, :telemere-receiving? false}}))
 
          (is (true? (tel/streams->telemere!)))
-         (is (sm?   (tel/check-interop) {:system/out {:sending->telemere? true,  :telemere-receiving? true},
+         (is (sm?   (tel/check-intakes) {:system/out {:sending->telemere? true,  :telemere-receiving? true},
                                          :system/err {:sending->telemere? true,  :telemere-receiving? true}}))
 
          (is (true? (tel/streams->reset!)))
-         (is (sm?   (tel/check-interop) {:system/out {:sending->telemere? false, :telemere-receiving? false},
+         (is (sm?   (tel/check-intakes) {:system/out {:sending->telemere? false, :telemere-receiving? false},
                                          :system/err {:sending->telemere? false, :telemere-receiving? false}}))
 
          (is (sm? (with-sig (tel/with-out->telemere (println "Hello" "x" "y")))
                {:level :info, :location nil, :ns nil, :kind :system/out, :msg_ "Hello x y"}))])
 
       (testing "SLF4J -> Telemere"
-        [(is (sm? (tel/check-interop) {:slf4j {:present? true, :sending->telemere? true, :telemere-receiving? true}}))
+        [(is (sm? (tel/check-intakes) {:slf4j {:present? true, :sending->telemere? true, :telemere-receiving? true}}))
          (let [^org.slf4j.Logger sl (org.slf4j.LoggerFactory/getLogger "MyTelemereSLF4JLogger")]
            [(testing "Basics"
               [(is (sm? (with-sig (.info sl "Hello"))               {:level :info, :location nil, :ns nil, :kind :log, :id :taoensso.telemere/slf4j, :msg_ "Hello"}) "Legacy API: info basics")