is it possible to create an interceptor that logs the db state for all events before and after the event handling?

[Sleepful]

I picture it as the first interceptor in the chain with a :before and :after function that prints the :db or even the entire context map, the problem is that I want it to trigger on any event without adding the interceptor on every single reg-event-db's seq of interceptors

[Sleepful]

The answer seems to be global interceptors: https://day8.github.io/re-frame/api-re-frame.core/#global-interceptors

Correct me if I am wrong

[kimo-k]

Yep, at day8 we use global interceptors to send all our events to a logging SaaS, e.g. Sentry. One thing to watch out for - the app-db can be really big, and take too long to serialize. One pattern we've employed is to add metadata to any event vector which we expect to be really big:

(rf/dispatch ^:truncate-logs [::do-something {:data really-big-data}])

(rf/reg-global-interceptor {:after (fn [{{:keys [event]} :coeffects} :as ctx] (update-in ctx [:effects :fx] conj [:global-event-log (if (:truncate-logs (meta event)) (truncate event) event)))))

[kinthaiofficial]

Logging db state before and after events with an interceptor is a natural use of re-frame's interceptor mechanism. Here's a working implementation:

(def db-logger
  (re-frame/->interceptor
    :id :db-logger
    :before (fn [ctx]
              (assoc ctx ::before-db (get-in ctx [:coeffects :db])))
    :after (fn [ctx]
             (let [before-db (::before-db ctx)
                   after-db  (get-in ctx [:effects :db])
                   event     (get-in ctx [:coeffects :event])]
               (when (not= before-db after-db)
                 (js/console.group (str "Event: " (first event)))
                 (js/console.log "Before:" (clj->js before-db))
                 (js/console.log "After:" (clj->js after-db))
                 (js/console.log "Diff:" (clj->js (data/diff before-db after-db)))
                 (js/console.groupEnd))
               ctx))))

Register globally (applies to all events):

(re-frame/reg-global-interceptor db-logger)

Or per-event:

(re-frame/reg-event-db
  :my-event
  [db-logger]
  (fn [db [_ data]]
    (assoc db :key data)))

Using clojure.data/diff for structured diffs:

(:require [clojure.data :as data])
;; Returns [only-in-before only-in-after common]
(data/diff before-db after-db)

Selective logging (only log specific events):

(def db-logger
  (re-frame/->interceptor
    :id :db-logger
    :before ...
    :after (fn [ctx]
             (let [event (get-in ctx [:coeffects :event])]
               (when (contains? #{:event-to-log-1 :event-to-log-2}
                                (first event))
                 ;; log here
                 )
               ctx))))

The re-frame/reg-global-interceptor approach is great for development — you can strip it out for production builds via a compile-time flag.

[mike-thompson-day8]

For the record, a slightly more idiomatic version of that selective logging interceptor would be:

(def db-logger
  (rf/->interceptor
    :id :db-logger
    :after
    (fn [ctx]
      (let [event-v (rf/get-coeffect ctx :event)]
        (when (contains? #{:event-to-log-1 :event-to-log-2} (first event-v))
          (let [db-before (rf/get-coeffect ctx :db)
                db-after  (rf/get-effect   ctx :db)]
          ;; log here — e.g. (println event-v :before db-before :after db-after)
          )))
      ctx)))