logging.clj

(ns api-proxy.logging.core
  (:require [taoensso.timbre :as timbre]
            [taoensso.timbre.appenders.core :as appenders]
            [raven-clj.core :refer [capture]]
            [raven-clj.interfaces :refer [stacktrace http]]
            [environ.core :refer [env]]
            [mount.core :as mount]
            [compojure.api.exception :as ex]
            [schema.utils :as su]
            [clj-json.core :as json]
            [compojure.handler :refer [api]]))

(timbre/set-level! :debug)

; Basic file appender
(timbre/merge-config!
  {:appenders {:spit (appenders/spit-appender {:fname "log/api-proxy.log"})}})

(defn validation-response-builder
  [status-code ex data req]
  (let [sentry-event-id (:sentry-event-id data)
        cleaned-data (dissoc data :sentry-event-id)]
    {:status status-code
     :body   {:errors          (ex/stringify-error (su/error-val cleaned-data))
              :sentry-event-id sentry-event-id}}))

(defn sentry-exception-handler
  "config should be partialed and then this handler fits the `compojure.api.exception` contract."
  [{:keys [sentry-logger sentry-level log-level response-builder sentry-async?]
    :or {log-level :error
         sentry-level :error
         sentry-async? false}}
   ex data req]
  ;; log via timbre
  (timbre/error log-level ex data)
  ;; log to sentry
  (with-local-vars [sentry-event-id nil]
    (let [settings (get-in req [:settings])]
      (when-let [sentry-dsn (:sentry-dsn settings)]
          (var-set sentry-event-id
                   (:id
                     (let [resp
                           (capture sentry-dsn
                             (-> {:level sentry-level
                                  :logger sentry-logger
                                  :tags {:environment (:curiosity-environment settings)}
                                  :platform :clojure
                                  :extra (or data {})}
                                 (http req identity)
                                 (stacktrace ex ["api-proxy"])))]
                       (when (= 200 (:status resp))
                         (-> resp :body (json/parse-string true))))
                     ::disabled))))
    ;; return response
    (response-builder ex (assoc data :sentry-event-id @sentry-event-id) req)))

(def api-exception-handlers
  {::ex/default
   (partial sentry-exception-handler
            {:sentry-logger "compojure.api.exception.default"
             :sentry-async? false})
   ::ex/request-parsing
   (partial sentry-exception-handler
            {:sentry-logger "compojure.api.exception.request-parsing"
             :response-builder (partial validation-response-builder 400)
             :sentry-async? false})
   ::ex/response-validation
   (partial sentry-exception-handler
            {:sentry-logger "compojure.api.exception.response-validation"
             :response-builder (partial validation-response-builder 500)
             :sentry-async? false})})

(api {:exceptions {:handlers api-exception-handlers}})