Ensure token_features and created_at are included in backend Snowplow events (#20523)

src/metabase/analytics/snowplow.clj

@@ -8,6 +8,7 @@
             [metabase.models.user :refer [User]]
             [metabase.public-settings :as public-settings]
             [metabase.util :as u]
+            [metabase.util.date-2 :as u.date]
             [metabase.util.i18n :as i18n :refer [deferred-tru trs]]
             [toucan.db :as db])
   (:import [com.snowplowanalytics.snowplow.tracker Subject$SubjectBuilder Tracker Tracker$TrackerBuilder]
@@ -52,6 +53,31 @@
                 "http://localhost:9090")
   :visibility :public)
 
+(defn- first-user-creation
+  "Returns the earliest user creation timestamp in the database"
+  []
+  (:min (db/select-one [User [:%min.date_joined :min]])))
+
+;; We need to declare `track-event!` up front so that we can use it in the custom getter of `instance-creation`.
+;; We can't move `instance-creation` below `track-event!` because it has to be defined before `context`, which is called
+;; by `track-event!`.
+(declare track-event!)
+
+(defsetting instance-creation
+  (deferred-tru "The approximate timestamp at which this instance of Metabase was created, for inclusion in analytics.")
+  :visibility :public
+  :type       :timestamp
+  :setter     :none
+  :getter     (fn []
+                (when-not (db/exists? Setting :key "instance-creation")
+                  ;; For instances that were started before this setting was added (in 0.41.3), use the creation
+                  ;; timestamp of the first user. For all new instances, use the timestamp at which this setting
+                  ;; is first read.
+                  (let [value (or (first-user-creation) (t/offset-date-time))]
+                    (setting/set-value-of-type! :timestamp :instance-creation value)
+                    (track-event! ::new-instance-created)))
+                (setting/get-value-of-type :timestamp :instance-creation)))
+
 (def ^:private emitter
   "Returns an instance of a Snowplow emitter"
   (let [emitter* (delay
@@ -100,7 +126,8 @@
        (str "iglu:com.metabase/instance/jsonschema/" (schema->version ::instance))
        {"id"             (analytics-uuid),
         "version"        {"tag" (:tag (public-settings/version))},
-        "token-features" (m/map-keys name (public-settings/token-features))}))
+        "token_features" (m/map-keys name (public-settings/token-features))
+        "created_at"     (u.date/format (instance-creation))}))
 
 (defn- normalize-kw
   [kw]
@@ -148,26 +175,3 @@
         (track-event-impl! (tracker) event))
       (catch Throwable e
         (log/debug e (trs "Error sending Snowplow analytics event {0}" event-kw))))))
-
-;; Instance creation timestamp setting.
-;; Must be defined after [[track-event!]] since it sends a Snowplow event the first time the setting is read.
-
-(defn- first-user-creation
-  "Returns the earliest user creation timestamp in the database"
-  []
-  (:min (db/select-one [User [:%min.date_joined :min]])))
-
-(defsetting instance-creation
-  (deferred-tru "The approximate timestamp at which this instance of Metabase was created, for inclusion in analytics.")
-  :visibility :public
-  :type       :timestamp
-  :setter     :none
-  :getter     (fn []
-                (when-not (db/exists? Setting :key "instance-creation")
-                  ;; For instances that were started before this setting was added (in 0.41.3), use the creation
-                  ;; timestamp of the first user. For all new instances, use the timestamp at which this setting
-                  ;; is first read.
-                  (let [value (or (first-user-creation) (t/offset-date-time))]
-                    (setting/set-value-of-type! :timestamp :instance-creation value)
-                    (track-event! ::new-instance-created)))
-                (setting/get-value-of-type :timestamp :instance-creation)))

test/metabase/analytics/snowplow_test.clj

@@ -8,6 +8,7 @@
             [metabase.test :as mt]
             [metabase.test.fixtures :as fixtures]
             [metabase.util :as u]
+            [metabase.util.date-2 :as u.date]
             [toucan.db :as db])
   (:import java.util.LinkedHashMap))
 
@@ -70,13 +71,15 @@
          events)))
 
 (deftest custom-content-test
-  (testing "Snowplow events include a custom context that includes the schema, instance ID, version and token features"
+  (testing "Snowplow events include a custom context that includes the schema, instance ID, version, token features
+           and creation timestamp"
     (with-fake-snowplow-collector
       (snowplow/track-event! ::snowplow/new-instance-created)
       (is (= {:schema "iglu:com.metabase/instance/jsonschema/1-1-0",
               :data {:id             (snowplow/analytics-uuid)
                      :version        {:tag (:tag (public-settings/version))},
-                     :token-features (public-settings/token-features)}}
+                     :token_features (public-settings/token-features)
+                     :created_at     (u.date/format (snowplow/instance-creation))}}
              (:context (first @*snowplow-collector*)))))))
 
 (deftest ip-address-override-test
@@ -90,7 +93,9 @@
   (with-fake-snowplow-collector
     (testing "Data sent into [[snowplow/track-event!]] for each event type is propagated to the Snowplow collector,
              with keys converted into snake-case strings, and the subject's user ID being converted to a string."
-      (snowplow/track-event! ::snowplow/new-instance-created)
+      ;; Trigger instance-creation event by calling the `instance-creation` setting function for the first time
+      (db/delete! Setting :key "instance-creation")
+      (snowplow/instance-creation)
       (is (= [{:data    {"event" "new_instance_created"}
                :user-id nil}]
              (pop-event-data-and-user-id!)))
@@ -139,7 +144,7 @@
   (let [original-value (db/select-one-field :value Setting :key "instance-creation")]
     (try
       (testing "Instance creation timestamp is set only once when setting is first fetched"
-        (db/delete! Setting {:key "instance-creation"})
+        (db/delete! Setting :key "instance-creation")
         (with-redefs [snowplow/first-user-creation (constantly nil)]
           (let [first-value (snowplow/instance-creation)]
             (Thread/sleep 10) ;; short sleep since java.time.Instant is not necessarily monotonic
@@ -148,7 +153,7 @@
 
       (testing "If a user already exists, we should use the first user's creation timestamp"
         (mt/with-test-user :crowberto
-          (db/delete! Setting {:key "instance-creation"})
+          (db/delete! Setting :key "instance-creation")
           (let [first-user-creation (:min (db/select-one ['User [:%min.date_joined :min]]))
                 instance-creation   (snowplow/instance-creation)]
             (is (= (java-time/local-date-time first-user-creation)