Grab cookie header from the map of request headers

Fixes #70

-=david=-

Author: dharrigan

CHANGELOG.md

@@ -10,6 +10,10 @@ endeavour to be non-breaking (by moving to new names rather than by
 breaking existing names). COMMITS is an ever-increasing counter of
 commits since the beginning of this repository.
 
+## [8.20.229]
+
+- Grab cookie header from the map of request headers. Fixes #70
+
 ## [8.20.228]
 
 - Update Sentry Java SDK to 8.20.0
@@ -448,7 +452,8 @@ commits since the beginning of this repository.
   compatible with Sentry 10.0.1 and below. If you wish to use those
   versions, please continue to use sentry-clj 1.7.30.
 
-[Unreleased]: https://github.com/getsentry/sentry-clj/compare/8.20.228...HEAD
+[Unreleased]: https://github.com/getsentry/sentry-clj/compare/8.20.229...HEAD
+[8.20.229]: https://github.com/getsentry/sentry-clj/compare/8.20.228...8.20.229
 [8.20.228]: https://github.com/getsentry/sentry-clj/compare/7.22.227...8.20.228
 [7.22.227]: https://github.com/getsentry/sentry-clj/compare/7.20.226...7.22.227
 [7.20.226]: https://github.com/getsentry/sentry-clj/compare/7.19.225...7.20.226

deps.edn

@@ -20,8 +20,8 @@
                                com.github.seancorfield/expectations {:mvn/version "2.2.214"}
                                lambdaisland/kaocha {:mvn/version "1.91.1392"}
                                lambdaisland/kaocha-junit-xml {:mvn/version "1.17.101"}
-                               orchestra/orchestra {:mvn/version "2021.01.01-1"}
-                               org.clojure/test.check {:mvn/version "1.1.1"}}}
+                               org.clojure/test.check {:mvn/version "1.1.1"}
+                               ring/ring-mock {:mvn/version "0.6.2"}}}
 
            :antq {:replace-deps {com.github.liquidz/antq {:mvn/version "2.11.1276"}
                                  org.slf4j/slf4j-nop {:mvn/version "2.0.17"}}
@@ -30,7 +30,6 @@
                   :exec-args {:download true
                               :force true
                               :no-changes true
-                              :skip ["pom"]
                               :upgrade true
                               :verbose true}}
 

examples/ring_with_tracing/src/ring_with_tracing/main.clj

@@ -4,20 +4,28 @@
    [ring.adapter.jetty :refer [run-jetty]]
    [ring.middleware.json :refer [wrap-json-params wrap-json-response]]
    [ring.middleware.keyword-params :refer [wrap-keyword-params]]
+   [ring.middleware.params :refer [wrap-params]]
    [sentry-clj.core :as sentry]
    [sentry-clj.ring :refer [wrap-report-exceptions wrap-sentry-tracing]]
    [sentry-clj.tracing :refer [with-start-child-span]]))
 
 (def config
   {:adapter/jetty {:port 8080 :handler (ig/ref :handler/router)}
-   :handler/router {:dsn "http://da98da654fbc48f901ef3ff7cb173e4e@localhost:9000/1" :app (ig/ref :handler/hello)}
+   ;;
+   ;; Change the DSN below to suit your particular setup.
+   ;;
+   :handler/router {:dsn "http://6b3a553a3c70d550ff5dea8c4a646b9f@localhost:9000/1" :app (ig/ref :handler/hello)}
    :handler/hello {:name "Sentry"}})
 
 (defmethod ig/init-key :adapter/jetty [_ {:keys [handler] :as opts}]
   (run-jetty handler (-> opts (dissoc :handler) (assoc :join? false))))
 
 (defmethod ig/init-key :handler/hello [_ {:keys [name]}]
-  (fn [_request]
+  (fn [{:keys [query-params] :as _request}]
+
+    ;; use ?throw=true to trigger an exception to thrown
+    (when (get query-params "throw")
+      (throw (RuntimeException. "I'm being exceptional")))
 
     (with-start-child-span "task" "my-child-operation"
       (Thread/sleep 1000))
@@ -31,6 +39,7 @@
   (-> app
       (wrap-report-exceptions {})
       (wrap-sentry-tracing)
+      (wrap-params)
       (wrap-keyword-params)
       (wrap-json-params)
       (wrap-json-response)))

src/sentry_clj/core.clj

@@ -54,46 +54,46 @@
 (defn ^:private map->user
   "Converts a map into a User."
   ^User
-  [{:keys [email id username ip-address data]}]
+  [{:keys [data email id ip-address username]}]
   (let [user (User.)]
+    (when data
+      (.setData user data))
     (when email
       (.setEmail user email))
     (when id
       (.setId user id))
-    (when username
-      (.setUsername user username))
     (when ip-address
       (.setIpAddress user ip-address))
-    (when data
-      (.setData user data))
+    (when username
+      (.setUsername user username))
     user))
 
 (defn ^:private map->request
   "Converts a map into a Request."
   ^Request
-  [{:keys [url method query-string data cookies headers env other]}]
+  [{:keys [data env headers method other query-string url] :as _request}]
   (let [request (Request.)]
-    (when url
-      (.setUrl request url))
-    (when method
-      (.setMethod request method))
-    (when query-string
-      (.setQueryString request query-string))
     (when data
       (.setData request (java-util-hashmappify-vals data)))
-    (when cookies
-      (.setCookies request (java-util-hashmappify-vals cookies)))
-    (when headers
-      (.setHeaders request (java-util-hashmappify-vals headers)))
     (when env
       (.setEnvs request (java-util-hashmappify-vals env)))
+    (when headers
+      (.setHeaders request (java-util-hashmappify-vals headers))
+      (when-let [cookie (get headers "cookie" (get headers "Cookie"))]
+        (.setCookies request cookie)))
+    (when method
+      (.setMethod request method))
     (when other
       (.setOthers request (java-util-hashmappify-vals other)))
+    (when query-string
+      (.setQueryString request query-string))
+    (when url
+      (.setUrl request url))
     request))
 
 (defn ^:private merge-all-ex-data
   "Merges ex-data of all ex-info exceptions in the cause chain of exn into extra.
-  Each ex-data is added under a separate key so that they don't clobber each other."
+   Each ex-data is added under a separate key so that they don't clobber each other."
   [extra exn]
   (loop [exn exn
          num 0
@@ -103,18 +103,13 @@
         (recur (ex-cause exn)
                (inc num)
                (cond-> extra
-                 data
-                 (assoc (if (zero? num)
-                          "ex-data"
-                          (str "ex-data, cause " num ": " (ex-message exn)))
-                        data))))
+                 data (assoc (if (zero? num) "ex-data" (str "ex-data, cause " num ": " (ex-message exn))) data))))
       extra)))
 
 (defn ^:private map->event
   "Converts a map into an event."
   ^SentryEvent
-  [{:keys [event-id message level release environment user request logger platform dist
-           tags breadcrumbs server-name extra fingerprints throwable transaction]}]
+  [{:keys [event-id message level release environment user request logger platform dist tags breadcrumbs server-name extra fingerprints throwable transaction] :as _event}]
   (let [sentry-event (SentryEvent. (DateUtils/getCurrentDateTime))
         updated-message (if (string? message) {:message message} message)]
     (when event-id

src/sentry_clj/ring.clj

@@ -17,12 +17,12 @@
 (defn ^:private request->http
   "Converts a Ring request into an HTTP interface for an event."
   [req]
-  {:url (request-url req)
+  {:data (:params req)
+   :env {:session (-> req :session pr-str) "REMOTE_ADDR" (:remote-addr req)}
+   :headers (:headers req)
    :method (-> req :request-method name)
-   :data (:params req)
    :query-string (:query-string req "")
-   :headers (:headers req)
-   :env {:session (-> req :session pr-str) "REMOTE_ADDR" (:remote-addr req)}})
+   :url (request-url req)})
 
 (defn ^:private configure-scope!
   "Set a scopes callback function which is called
@@ -58,11 +58,11 @@
 (defn ^:private request->context-request
   "Converts a request into custom-sampling-context's request."
   [req]
-  {:uri (request-url req)
-   :query-string (:query-string req "")
-   :method (-> req :request-method name upper-case)
+  {:data (-> req :params)
    :headers (:headers req)
-   :data (-> req :params)})
+   :query-string (:query-string req "")
+   :request-method (-> req :request-method name upper-case)
+   :uri (request-url req)})
 
 (defn ^:private compute-sentry-runtime
   "Compute Clojure runtime information."

test/sentry_clj/core_test.clj

@@ -48,7 +48,8 @@
              :method "GET"
              :query-string "?foo=bar"
              :cookies "cookie1=foo;cookie2=bar"
-             :headers {"X-Clacks-Overhead" "Terry Pratchett"
+             :headers {"Cookie" "cookie1=foo;cookie2=bar"
+                       "X-Clacks-Overhead" "Terry Pratchett"
                        "X-w00t" "ftw!"}
              :env {"a" "b"}
              :data {"c" "d"}
@@ -102,8 +103,8 @@
     (let [request ^Request (#'sut/map->request {:url "http://example.com"
                                                 :method "GET"
                                                 :query-string "?foo=bar"
-                                                :cookies "cookie1=foo;cookie2=bar"
-                                                :headers {"X-Clacks-Overhead" "Terry Pratchett"
+                                                :headers {"Cookie" "cookie1=foo;cookie2=bar"
+                                                          "X-Clacks-Overhead" "Terry Pratchett"
                                                           "X-w00t" "ftw!"}
                                                 :env {"a" "b"}
                                                 :data {"c" "d"}
@@ -112,7 +113,7 @@
       (expect "GET" (.getMethod request))
       (expect "?foo=bar" (.getQueryString request))
       (expect "cookie1=foo;cookie2=bar" (.getCookies request))
-      (expect {"X-Clacks-Overhead" "Terry Pratchett" "X-w00t" "ftw!"} (.getHeaders request))
+      (expect {"Cookie" "cookie1=foo;cookie2=bar" "X-Clacks-Overhead" "Terry Pratchett" "X-w00t" "ftw!"} (.getHeaders request))
       (expect {"a" "b"} (.getEnvs request))
       (expect {"c" "d"} (.getData request))
       (expect {"x" "y"} (.getOthers request)))))
@@ -144,7 +145,7 @@
                        "username" "username"}
                "request" {"cookies" "cookie1=foo;cookie2=bar"
                           "env" {"a" "b"}
-                          "headers" {"X-Clacks-Overhead" "Terry Pratchett", "X-w00t" "ftw!"}
+                          "headers" {"Cookie" "cookie1=foo;cookie2=bar" "X-Clacks-Overhead" "Terry Pratchett", "X-w00t" "ftw!"}
                           "method" "GET"
                           "data" {"c" "d"}
                           "other" {"x" "y"}
@@ -183,7 +184,7 @@
                        "username" "username"}
                "request" {"cookies" "cookie1=foo;cookie2=bar"
                           "env" {"a" "b"}
-                          "headers" {"X-Clacks-Overhead" "Terry Pratchett", "X-w00t" "ftw!"}
+                          "headers" {"Cookie" "cookie1=foo;cookie2=bar" "X-Clacks-Overhead" "Terry Pratchett", "X-w00t" "ftw!"}
                           "method" "GET"
                           "data" {"c" "d"}
                           "other" {"x" "y"}
@@ -229,7 +230,7 @@
                        "username" "username"}
                "request" {"cookies" "cookie1=foo;cookie2=bar"
                           "env" {"a" "b"}
-                          "headers" {"X-Clacks-Overhead" "Terry Pratchett", "X-w00t" "ftw!"}
+                          "headers" {"Cookie" "cookie1=foo;cookie2=bar" "X-Clacks-Overhead" "Terry Pratchett", "X-w00t" "ftw!"}
                           "method" "GET"
                           "data" {"c" "d"}
                           "other" {"x" "y"}
@@ -278,7 +279,7 @@
                        "username" "username"}
                "request" {"cookies" "cookie1=foo;cookie2=bar"
                           "env" {"a" "b"}
-                          "headers" {"X-Clacks-Overhead" "Terry Pratchett", "X-w00t" "ftw!"}
+                          "headers" {"Cookie" "cookie1=foo;cookie2=bar" "X-Clacks-Overhead" "Terry Pratchett", "X-w00t" "ftw!"}
                           "method" "GET"
                           "data" {"c" "d"}
                           "other" {"x" "y"}

test/sentry_clj/ring_test.clj

@@ -2,6 +2,8 @@
   (:require
    [cheshire.core :as json]
    [expectations.clojure.test :refer [defexpect expect expecting side-effects]]
+   [ring.middleware.cookies :as cookies-middleware]
+   [ring.mock.request :as mock]
    [sentry-clj.core :as sentry]
    [sentry-clj.ring :as ring]
    [sentry-clj.tracing :as st])
@@ -28,9 +30,9 @@
 
 (defn ^:private wrapped
   [req]
-  (if (:ok req) "woo" (throw e)))
+  (if (:ok req) "w00t" (throw e)))
 
-(def ^:private req
+(def ^:private hello-world-request
   {:scheme :https
    :uri "/hello-world"
    :request-method :get
@@ -55,7 +57,7 @@
 (defexpect wrap-report-exceptions-test
   (expecting "passing through"
     (let [handler (ring/wrap-report-exceptions wrapped {})]
-      (expect "woo" (handler (assoc req :ok true))))))
+      (expect "w00t" (handler (assoc hello-world-request :ok true))))))
 
 (defexpect with-defaults-test
   (expecting "with defaults"
@@ -72,7 +74,7 @@
       (expect {:status 500
                :headers {"Content-Type" "text/html"}
                :body "<html><head><title>Error</title></head><body><p>Internal Server Error</p></body></html>"}
-        (handler req))
+        (handler hello-world-request))
       (expect {"breadcrumbs" (),
                "contexts" {},
                "request" {"data" {"one" 1},
@@ -98,7 +100,7 @@
           handler (ring/wrap-report-exceptions wrapped {:preprocess-fn preprocess
                                                         :postprocess-fn postprocess
                                                         :error-fn error})]
-      (expect (assoc req :exception e) (handler req))
+      (expect (assoc hello-world-request :exception e) (handler hello-world-request))
       (expect {"breadcrumbs" (),
                "contexts" {},
                "environment" "qa",
@@ -123,11 +125,11 @@
 
 (defexpect wrap-sentry-tracing-test
   (let [sentry-options (get-test-options {:traces-sample-rate 1.0 :debug true})
-        ok-req (assoc req :ok true)]
+        ok-req (assoc hello-world-request :ok true)]
     (Sentry/init ^SentryOptions sentry-options)
     (expecting "passing through"
       (let [handler (ring/wrap-sentry-tracing wrapped)]
-        (expect "woo" (handler ok-req))))
+        (expect "w00t" (handler ok-req))))
     (expecting "preprocess fn called"
       (let [handler (ring/wrap-sentry-tracing wrapped {:preprocess-fn preprocess})]
         (expect (fn [_transaction]
@@ -138,4 +140,32 @@
                                                   (deliver p (.getData (.getRequest scope))))))
                        @p)))
           (side-effects [st/finish-transaction!]
-            (expect "woo" (handler ok-req))))))))
+            (expect "w00t" (handler ok-req))))))))
+
+(defexpect cookie-decoding-test
+  (expecting "cookies are decoded properly"
+    (let [event {:throwable e
+                 :request {:url "https://example.com/hello-world"
+                           :method nil
+                           :data {:one 1}
+                           :query-string ""
+                           :headers {"cookie" "sessionId=1234" "ok" 2 "host" "example.com"}
+                           :env {:session "{}" "REMOTE_ADDR" "127.0.0.1"}}
+                 :user {:ip_address "127.0.0.1"}}
+          sentry-event (strip-timestamp (serialize event))
+          handler (-> (ring/wrap-report-exceptions wrapped {})
+                      (cookies-middleware/wrap-cookies))
+          request (-> (assoc hello-world-request :ok false)
+                      (mock/cookie :sessionId "1234"))
+          {:keys [status] :as response} (handler request)]
+      (expect 500 status)
+      (expect {"breadcrumbs" (),
+               "contexts" {},
+               "request" {"cookies" "sessionId=1234",
+                          "data" {"one" 1},
+                          "env" {"REMOTE_ADDR" "127.0.0.1", "session" "{}"},
+                          "headers" {"cookie" "sessionId=1234", "host" "example.com", "ok" 2},
+                          "query_string" "",
+                          "url" "https://example.com/hello-world"},
+               "sdk" {"version" "blah"},
+               "user" {}} sentry-event))))