✨ Improve logging performance and format.

backend/src/app/http/errors.clj

@@ -11,6 +11,7 @@
    [app.common.logging :as l]
    [app.common.uuid :as uuid]
    [clojure.pprint]
+   [clojure.spec.alpha :as s]
    [cuerdas.core :as str]))
 
 (defn- parse-client-ip
@@ -23,22 +24,20 @@
   [request error]
   (let [data (ex-data error)]
     (merge
-     {:id         (uuid/next)
-      :path       (:uri request)
-      :method     (:request-method request)
-      :hint       (or (:hint data) (ex-message error))
-      :params     (l/stringify-data (:params request))
-      :data       (l/stringify-data (dissoc data :explain))
-      :ip-addr    (parse-client-ip request)
-      :profile-id (:profile-id request)}
+     {:id            (uuid/next)
+      :path          (:uri request)
+      :method        (:request-method request)
+      :hint          (or (:hint data) (ex-message error))
+      :params        (l/stringify-data (:params request))
+      :spec-problems (some-> data ::s/problems)
+      :ip-addr       (parse-client-ip request)
+      :profile-id    (:profile-id request)}
 
      (let [headers (:headers request)]
        {:user-agent (get headers "user-agent")
         :frontend-version (get headers "x-frontend-version" "unknown")})
 
-     (when (map? data)
-       {:error-type (:type data)
-        :error-code (:code data)}))))
+     (dissoc data ::s/problems))))
 
 (defmulti handle-exception
   (fn [err & _rest]
@@ -66,17 +65,17 @@
                   (:explain edata)
                   "</pre>\n")}
       {:status 400
-       :body   (dissoc edata :data)})))
+       :body   (dissoc edata ::s/problems)})))
 
 (defmethod handle-exception :assertion
   [error request]
   (let [edata (ex-data error)]
     (l/with-context (get-error-context request error)
-      (l/error :hint "internal error: assertion" :cause error))
+      (l/error :hint (ex-message error) :cause error))
     {:status 500
      :body {:type :server-error
             :code :assertion
-            :data (dissoc edata :data)}}))
+            :data (dissoc edata ::s/problems)}}))
 
 (defmethod handle-exception :not-found
   [err _]

backend/src/app/loggers/database.clj

@@ -36,7 +36,7 @@
     (db/insert! conn :server-error-report
                 {:id id :content (db/tjson event)})))
 
-(defn- parse-context
+(defn- parse-event-data
   [event]
   (reduce-kv
    (fn [acc k v]
@@ -46,12 +46,11 @@
        (str/blank? v)    acc
        :else             (assoc acc k v)))
    {}
-   (:context event)))
+   event))
 
 (defn parse-event
   [event]
-  (-> (parse-context event)
-      (merge (dissoc event :context))
+  (-> (parse-event-data event)
       (assoc :tenant (cf/get :tenant))
       (assoc :host (cf/get :host))
       (assoc :public-uri (cf/get :public-uri))
@@ -62,6 +61,7 @@
   (aa/with-thread executor
     (try
       (let [event (parse-event event)]
+        (l/debug :hint "registering error on database" :id (:id event))
         (persist-on-database! cfg event))
       (catch Exception e
         (l/warn :hint "unexpected exception on database error logger"
@@ -74,7 +74,8 @@
   [_ {:keys [receiver] :as cfg}]
   (l/info :msg "initializing database error persistence")
   (let [output (a/chan (a/sliding-buffer 128)
-                       (filter #(= (:level %) "error")))]
+                       (filter (fn [event]
+                                 (= (:logger/level event) "error"))))]
     (receiver :sub output)
     (a/go-loop []
       (let [msg (a/<! output)]

backend/src/app/loggers/zmq.clj

@@ -92,19 +92,15 @@
 (defn- prepare
   [event]
   (if (s/valid? ::log4j-event event)
-    (merge
-     {:logger     (:logger-name event)
-      :level      (str/lower (:level event))
-      :thread     (:thread event)
-      :created-at (dt/instant (:time-millis event))
-      :message    (:message event)}
-     (when-let [ctx (:context-map event)]
-       {:context ctx})
-     (when-let [thrown (:thrown event)]
-       {:error
-        {:class (:name thrown)
-         :message (:message thrown)
-         :trace (:extended-stack-trace thrown)}}))
+    (merge {:message      (:message event)
+            :created-at   (dt/instant (:time-millis event))
+            :logger/name  (:logger-name event)
+            :logger/level (str/lower (:level event))}
+
+           (when-let [thrown (:thrown event)]
+             {:trace (:extended-stack-trace thrown)})
+
+           (:context-map event))
     (do
       (l/warn :hint "invalid event" :event event)
       nil)))