Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Enforce session timeout server-side with last_active_at tracking (#71866)

Edward Paget3392486525d5
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 24f735a8024..72c8f500d41 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -1770,6 +1770,7 @@
config
embedding
permissions ; FIXME
+ premium-features
session
settings
users
@@ -1903,7 +1904,8 @@
tracing
users
util
- enterprise/sso}}
+ enterprise/sso}
+ :model-imports #{:model/Session}}
session
{:team "UX West"
diff --git a/enterprise/backend/test/metabase_enterprise/api/session_test.clj b/enterprise/backend/test/metabase_enterprise/api/session_test.clj
index 1a89f015672..3ab3dda39e8 100644
--- a/enterprise/backend/test/metabase_enterprise/api/session_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/api/session_test.clj
@@ -2,8 +2,15 @@
;; TODO (Cam 10/30/25) -- Move this somewhere better
(:require
[clojure.test :refer :all]
+ [metabase.app-db.core :as mdb]
+ [metabase.initialization-status.core :as init-status]
+ [metabase.server.middleware.session :as mw.session]
+ [metabase.session.core :as session]
+ [metabase.session.task.session-cleanup :as session-cleanup]
[metabase.test :as mt]
- [metabase.test.fixtures :as fixtures]))
+ [metabase.test.fixtures :as fixtures]
+ [metabase.util.honey-sql-2 :as h2x]
+ [toucan2.core :as t2]))
(use-fixtures :once (fixtures/initialize :db))
@@ -109,3 +116,108 @@
:workspaces true
:writable_connection true}
(:token-features (mt/user-http-request :crowberto :get 200 "session/properties"))))))
+
+;;; ---------------------------------------- server-side session timeout tests -----------------------------------------
+
+(deftest session-timeout-enforces-last-active-at-test
+ (init-status/set-complete!)
+ (mt/with-premium-features #{:session-timeout-config}
+ (mt/with-temporary-setting-values [session-timeout {:amount 5 :unit "minutes"}]
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [session-id (session/generate-session-id)
+ session-key (str (random-uuid))
+ key-hashed (session/hash-session-key session-key)]
+ (testing "Session with recent last_active_at should be valid"
+ (t2/insert! (t2/table-name :model/Session)
+ {:id session-id :key_hashed key-hashed :user_id user-id :created_at :%now
+ :last_active_at :%now})
+ (is (some? (#'mw.session/current-user-info-for-session session-key nil))))
+
+ (testing "Session with last_active_at older than timeout should be expired"
+ (t2/query-one {:update (t2/table-name :model/Session)
+ :set {:last_active_at (h2x/add-interval-honeysql-form (mdb/db-type) :%now -301 :second)}
+ :where [:= :key_hashed key-hashed]})
+ (is (nil? (#'mw.session/current-user-info-for-session session-key nil))))
+
+ (testing "Session with last_active_at just within timeout should be valid"
+ (t2/query-one {:update (t2/table-name :model/Session)
+ :set {:last_active_at (h2x/add-interval-honeysql-form (mdb/db-type) :%now -299 :second)}
+ :where [:= :key_hashed key-hashed]})
+ (is (some? (#'mw.session/current-user-info-for-session session-key nil)))))))))
+
+(deftest session-timeout-falls-back-to-created-at-test
+ (init-status/set-complete!)
+ (mt/with-premium-features #{:session-timeout-config}
+ (mt/with-temporary-setting-values [session-timeout {:amount 5 :unit "minutes"}]
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [session-id (session/generate-session-id)
+ session-key (str (random-uuid))
+ key-hashed (session/hash-session-key session-key)]
+
+ (testing "newly created session (NULL last_active_at) should be valid"
+ (t2/insert! (t2/table-name :model/Session)
+ {:id session-id :key_hashed key-hashed :user_id user-id :created_at :%now})
+ (is (some? (#'mw.session/current-user-info-for-session session-key nil))))
+
+ (testing "old session with NULL last_active_at should be expired"
+ (t2/query-one {:update (t2/table-name :model/Session)
+ :set {:created_at (h2x/add-interval-honeysql-form (mdb/db-type) :%now -301 :second)}
+ :where [:= :key_hashed key-hashed]})
+ (is (nil? (#'mw.session/current-user-info-for-session session-key nil)))))))))
+
+(deftest session-activity-update-throttle-test
+ (init-status/set-complete!)
+ (testing "maybe-update-session-activity! throttles DB writes"
+ (mt/with-premium-features #{:session-timeout-config}
+ (mt/with-temporary-setting-values [session-timeout {:amount 30 :unit "minutes"}]
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [session-id (session/generate-session-id)
+ session-key (str (random-uuid))
+ key-hashed (session/hash-session-key session-key)]
+ (session/clear-session-activity-cache!)
+ (t2/insert! (t2/table-name :model/Session)
+ {:id session-id :key_hashed key-hashed :user_id user-id :created_at :%now})
+
+ (testing "first call should update last_active_at"
+ (#'mw.session/maybe-update-session-activity! session-key)
+ (is (some? (t2/select-one-fn :last_active_at (t2/table-name :model/Session) :key_hashed key-hashed))))
+
+ (testing "immediate second call should be throttled (no error, just skipped)"
+ (let [first-value (t2/select-one-fn :last_active_at (t2/table-name :model/Session) :key_hashed key-hashed)]
+ (#'mw.session/maybe-update-session-activity! session-key)
+ (is (= first-value
+ (t2/select-one-fn :last_active_at (t2/table-name :model/Session) :key_hashed key-hashed)))))))))))
+
+;;; ---------------------------------------- session cleanup idle sessions test ----------------------------------------
+
+(deftest cleanup-idle-sessions-test
+ (testing "With session-timeout configured, idle sessions are also cleaned up"
+ (mt/with-premium-features #{:session-timeout-config}
+ (mt/with-temporary-setting-values [session-timeout {:amount 5 :unit "minutes"}]
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [active-id (session/generate-session-id)
+ active-key (session/hash-session-key (str (random-uuid)))
+ idle-id (session/generate-session-id)
+ idle-key (session/hash-session-key (str (random-uuid)))
+ no-activity-id (session/generate-session-id)
+ no-activity-key (session/hash-session-key (str (random-uuid)))]
+ ;; Active session: last_active_at = now
+ (t2/insert! (t2/table-name :model/Session)
+ {:id active-id :key_hashed active-key :user_id user-id
+ :created_at :%now :last_active_at :%now})
+ ;; Idle session: last_active_at = 10 minutes ago
+ (t2/insert! (t2/table-name :model/Session)
+ {:id idle-id :key_hashed idle-key :user_id user-id
+ :created_at :%now
+ :last_active_at (h2x/add-interval-honeysql-form (mdb/db-type) :%now -600 :second)})
+ ;; Session with no activity tracking (NULL last_active_at), created recently
+ (t2/insert! (t2/table-name :model/Session)
+ {:id no-activity-id :key_hashed no-activity-key :user_id user-id
+ :created_at :%now})
+ (#'session-cleanup/cleanup-sessions!)
+ (testing "active session is kept"
+ (is (t2/exists? :model/Session :id active-id)))
+ (testing "idle session is deleted"
+ (is (not (t2/exists? :model/Session :id idle-id))))
+ (testing "session with NULL last_active_at but recent created_at is kept"
+ (is (t2/exists? :model/Session :id no-activity-id)))))))))
diff --git a/resources/migrations/058_update_migrations.yaml b/resources/migrations/058_update_migrations.yaml
index 461a626818e..8db96390b37 100644
--- a/resources/migrations/058_update_migrations.yaml
+++ b/resources/migrations/058_update_migrations.yaml
@@ -1218,6 +1218,21 @@ databaseChangeLog:
tableName: pulse
columnName: disable_links
+ - changeSet:
+ id: v58.2026-04-01T10:00:00
+ author: epaget
+ comment: Add last_active_at to core_session for server-side session timeout enforcement
+ changes:
+ - addColumn:
+ tableName: core_session
+ columns:
+ - column:
+ name: last_active_at
+ type: ${timestamp_type}
+ remarks: Tracks when the session was last used, for inactivity timeout enforcement
+ constraints:
+ nullable: true
+
# >>>>>>>>>> DO NOT ADD NEW MIGRATIONS BELOW THIS LINE! ADD THEM ABOVE <<<<<<<<<<
########################################################################################################################
diff --git a/src/metabase/request/core.clj b/src/metabase/request/core.clj
index edb0cc22aaf..8b039e64dd4 100644
--- a/src/metabase/request/core.clj
+++ b/src/metabase/request/core.clj
@@ -1,6 +1,7 @@
(ns metabase.request.core
"API namespace for stuff related to Ring (HTTP) requests, such as info associated with the current request."
(:require
+ [metabase.premium-features.core :as premium-features]
[metabase.request.cookies]
[metabase.request.current]
[metabase.request.session]
@@ -26,6 +27,7 @@
metabase-embedded-session-cookie
metabase-session-cookie
metabase-session-timeout-cookie
+ session-timeout-seconds
set-session-cookies
set-session-timeout-cookie]
[metabase.request.current
@@ -56,3 +58,10 @@
https?
ip-address
public?])
+
+(defn enabled-session-timeout-seconds
+ "Return the session timeout in seconds if the session-timeout-config premium feature is enabled and a timeout is
+ configured, otherwise nil."
+ []
+ (when (premium-features/enable-session-timeout-config?)
+ (session-timeout-seconds)))
diff --git a/src/metabase/server/middleware/session.clj b/src/metabase/server/middleware/session.clj
index 94b4fb28482..2d4e4c8f374 100644
--- a/src/metabase/server/middleware/session.clj
+++ b/src/metabase/server/middleware/session.clj
@@ -96,9 +96,21 @@
;; Because this query runs on every single API request it's worth it to optimize it a bit and only compile it to SQL
;; once rather than every time
-(def ^:private ^{:arglists '([db-type max-age-minutes session-type enable-advanced-permissions? enable-tenants?])} session-with-id-query
+(defn- oldest-allowed-expr
+ "Build a database-specific expression for `NOW() - interval`."
+ [db-type amount unit]
+ (case db-type
+ :postgres [:- [:raw "current_timestamp"]
+ [:raw (format "INTERVAL '%d %s'" amount (name unit))]]
+ :h2 [:dateadd (h2x/literal (name unit))
+ [:inline (- amount)]
+ :%now]
+ :mysql [:date_add :%now
+ [:raw (format "INTERVAL -%d %s" amount (name unit))]]))
+
+(def ^:private ^{:arglists '([db-type max-age-minutes session-type enable-advanced-permissions? enable-tenants? session-timeout-seconds])} session-with-id-query
(memoize
- (fn [db-type max-age-minutes session-type enable-advanced-permissions? enable-tenants?]
+ (fn [db-type max-age-minutes session-type enable-advanced-permissions? enable-tenants? session-timeout-seconds]
(first
(t2.pipeline/compile*
(cond-> {:select [[:session.user_id :metabase-user-id]
@@ -108,27 +120,19 @@
:from [[:core_session :session]]
:left-join [[:core_user :user] [:= :session.user_id :user.id]
[:tenant] [:= :tenant.id :user.tenant_id]]
- :where [:and
- (if enable-tenants?
- [:or [:= :tenant.id nil] :tenant.is_active]
- [:= :tenant.id nil])
- [:= :user.is_active true]
- [:or [:= :session.id [:raw "?"]] [:= :session.key_hashed [:raw "?"]]]
- (let [oldest-allowed (case db-type
- :postgres [:-
- [:raw "current_timestamp"]
- [:raw (format "INTERVAL '%d minute'" max-age-minutes)]]
- :h2 [:dateadd
- (h2x/literal "minute")
- [:inline (- max-age-minutes)]
- :%now]
- :mysql [:date_add
- :%now
- [:raw (format "INTERVAL -%d minute" max-age-minutes)]])]
- [:> :session.created_at oldest-allowed])
- [:= :session.anti_csrf_token (case session-type
- :normal nil
- :full-app-embed [:raw "?"])]]
+ :where (into [:and
+ (if enable-tenants?
+ [:or [:= :tenant.id nil] :tenant.is_active]
+ [:= :tenant.id nil])
+ [:= :user.is_active true]
+ [:or [:= :session.id [:raw "?"]] [:= :session.key_hashed [:raw "?"]]]
+ [:> :session.created_at (oldest-allowed-expr db-type max-age-minutes :minute)]
+ [:= :session.anti_csrf_token (case session-type
+ :normal nil
+ :full-app-embed [:raw "?"])]]
+ (when session-timeout-seconds
+ [[:> [:coalesce :session.last_active_at :session.created_at]
+ (oldest-allowed-expr db-type session-timeout-seconds :second)]]))
:limit [:inline 1]}
enable-advanced-permissions?
(->
@@ -179,15 +183,17 @@
"Return User ID and superuser status for Session with `session-key` if it is valid and not expired."
[session-key anti-csrf-token]
(when (and session-key (valid-session-key? session-key) (init-status/complete?))
- (let [sql (session-with-id-query (mdb/db-type)
- (config/config-int :max-session-age)
- (if (seq anti-csrf-token) :full-app-embed :normal)
- (premium-features/enable-advanced-permissions?)
- (and (premium-features/enable-tenants?)
- (setting/get :use-tenants)))
- params (concat [session-key (session/hash-session-key session-key)]
- (when (seq anti-csrf-token)
- [anti-csrf-token]))]
+ (let [timeout (request/enabled-session-timeout-seconds)
+ sql (session-with-id-query (mdb/db-type)
+ (config/config-int :max-session-age)
+ (if (seq anti-csrf-token) :full-app-embed :normal)
+ (premium-features/enable-advanced-permissions?)
+ (and (premium-features/enable-tenants?)
+ (setting/get :use-tenants))
+ timeout)
+ params (concat [session-key (session/hash-session-key session-key)]
+ (when (seq anti-csrf-token)
+ [anti-csrf-token]))]
(some-> (t2/query-one (cons sql params))
;; is-group-manager? could return `nil, convert it to boolean so it's guaranteed to be only true/false
(update :is-group-manager? boolean)))))
@@ -276,6 +282,24 @@
(with-current-user-for-request request
(handler request respond raise))))
+;;; +----------------------------------------------------------------------------------------------------------------+
+;;; | session activity tracking |
+;;; +----------------------------------------------------------------------------------------------------------------+
+
+(defn- maybe-update-session-activity!
+ "Update the `last_active_at` column for the session identified by `session-key`, throttled to avoid a DB write on
+ every request. Uses raw SQL to bypass the Session model's no-update restriction."
+ [session-key]
+ (when (request/enabled-session-timeout-seconds)
+ (let [hashed (session/hash-session-key session-key)]
+ (when (session/record-session-activity-update! hashed)
+ (try
+ (t2/query-one {:update (t2/table-name :model/Session)
+ :set {:last_active_at :%now}
+ :where [:= :key_hashed hashed]})
+ (catch Exception e
+ (log/warn e "Failed to update session last_active_at")))))))
+
;;; +----------------------------------------------------------------------------------------------------------------+
;;; | reset-cookie-timeout |
;;; +----------------------------------------------------------------------------------------------------------------+
@@ -301,5 +325,9 @@
request-time (t/zoned-date-time (t/zone-id "GMT"))]
(handler request
(fn [response]
+ ;; Update last_active_at for server-side timeout enforcement
+ (when-let [session-key (:metabase-session-key request)]
+ (when (:metabase-user-id request)
+ (maybe-update-session-activity! session-key)))
(respond (reset-session-timeout* request response request-time)))
raise))))
diff --git a/src/metabase/session/core.clj b/src/metabase/session/core.clj
index 8d397517ee0..4252ffdc7e0 100644
--- a/src/metabase/session/core.clj
+++ b/src/metabase/session/core.clj
@@ -2,8 +2,11 @@
(:require
[metabase.session.models.session]
[metabase.session.settings]
+ [metabase.util :as u]
[potemkin :as p]))
+(set! *warn-on-reflection* true)
+
(comment metabase.session.models.session/keep-me
metabase.session.settings/keep-me)
@@ -17,3 +20,39 @@
enable-password-login!
password-complexity
session-cookies))
+
+;;; ------------------------------------------------ session activity tracking -----------------------------------------
+
+(def ^:private session-last-update-times
+ "In-memory cache of {session-key-hash -> timer} used to throttle DB writes for last_active_at updates.
+ Each session's last_active_at is only written to the DB at most once per `activity-update-throttle-ms`.
+ Timer values are opaque, created by [[metabase.util/start-timer]]."
+ (atom {}))
+
+(def ^:private activity-update-throttle-ms
+ "Minimum interval between last_active_at DB writes for the same session, in milliseconds."
+ 60000)
+
+(defn record-session-activity-update!
+ "Atomically record that a session activity update is happening now if enough time has elapsed since the last update.
+ Returns true if the caller should proceed with the DB write, false if throttled."
+ [key-hash]
+ (let [now (u/start-timer)
+ old-val @session-last-update-times
+ timer (get old-val key-hash)]
+ (if (or (nil? timer)
+ (> (u/since-ms timer) activity-update-throttle-ms))
+ (compare-and-set! session-last-update-times old-val (assoc old-val key-hash now))
+ false)))
+
+(defn prune-session-activity-cache!
+ "Remove entries from the session activity throttle cache that are older than the throttle window.
+ Called by the session cleanup task to prevent unbounded growth."
+ []
+ (swap! session-last-update-times
+ (fn [m] (into {} (filter (fn [[_ timer]] (<= (u/since-ms timer) activity-update-throttle-ms))) m))))
+
+(defn clear-session-activity-cache!
+ "Remove all entries from the session activity throttle cache. Intended for use in tests."
+ []
+ (reset! session-last-update-times {}))
diff --git a/src/metabase/session/task/session_cleanup.clj b/src/metabase/session/task/session_cleanup.clj
index 52e5422db21..4238228efe0 100644
--- a/src/metabase/session/task/session_cleanup.clj
+++ b/src/metabase/session/task/session_cleanup.clj
@@ -5,6 +5,8 @@
[clojurewerkz.quartzite.triggers :as triggers]
[metabase.app-db.core :as mdb]
[metabase.config.core :as config]
+ [metabase.request.core :as request]
+ [metabase.session.core :as session]
[metabase.task.core :as task]
[metabase.tracing.core :as tracing]
[metabase.util.honey-sql-2 :as h2x]
@@ -13,14 +15,26 @@
(set! *warn-on-reflection* true)
(defn- cleanup-sessions!
- "Deletes sessions from the database which are no longer valid"
+ "Deletes sessions from the database which are no longer valid. Removes sessions that exceed MAX_SESSION_AGE
+ (absolute lifetime) and also sessions that have been idle longer than the session-timeout setting (if configured)."
[]
(let [oldest-allowed [:inline (h2x/add-interval-honeysql-form (mdb/db-type)
:%now
(- (config/config-int :max-session-age))
:minute)]
- hsql {:delete-from [(t2/table-name :model/Session)]
- :where [:< :created_at oldest-allowed]}]
+ timeout-seconds (request/enabled-session-timeout-seconds)
+ timeout-oldest (when timeout-seconds
+ [:inline (h2x/add-interval-honeysql-form (mdb/db-type)
+ :%now
+ (- timeout-seconds)
+ :second)])
+ where-clause (if timeout-oldest
+ [:or
+ [:< :created_at oldest-allowed]
+ [:< [:coalesce :last_active_at :created_at] timeout-oldest]]
+ [:< :created_at oldest-allowed])
+ hsql {:delete-from [(t2/table-name :model/Session)]
+ :where where-clause}]
(tracing/with-span :tasks "task.session-cleanup.delete" {:db/statement (tracing/best-effort-sanitize-sql hsql)}
(t2/query-one hsql))))
@@ -30,7 +44,8 @@
(task/defjob ^{:doc "Job that cleans up outdated sessions."}
SessionCleanup
[_]
- (cleanup-sessions!))
+ (cleanup-sessions!)
+ (session/prune-session-activity-cache!))
(defmethod task/init! ::SessionCleanup [_]
(let [job (jobs/build
diff --git a/test/metabase/server/middleware/session_test.clj b/test/metabase/server/middleware/session_test.clj
index fd8efc9ed99..1dda0b0c25d 100644
--- a/test/metabase/server/middleware/session_test.clj
+++ b/test/metabase/server/middleware/session_test.clj
@@ -470,3 +470,20 @@
(let [request {:cookies {}}]
(is (= response
(mw.session/reset-session-timeout* request response request-time))))))))
+
+;;; ---------------------------------------- server-side session timeout tests -----------------------------------------
+;; Tests for session-timeout-enforces-last-active-at, session-timeout-falls-back-to-created-at, and
+;; session-activity-update-throttle are in metabase-enterprise.api.session-test because they require EE features.
+
+(deftest session-timeout-requires-premium-feature-test
+ (init-status/set-complete!)
+ (mt/with-premium-features #{}
+ (mt/with-temporary-setting-values [session-timeout {:amount 5 :unit "minutes"}]
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [session-id (session/generate-session-id)
+ session-key (str (random-uuid))
+ key-hashed (session/hash-session-key session-key)]
+ (t2/insert! (t2/table-name :model/Session)
+ {:id session-id :key_hashed key-hashed :user_id user-id :created_at :%now
+ :last_active_at (h2x/add-interval-honeysql-form (mdb/db-type) :%now -600 :second)})
+ (is (some? (#'mw.session/current-user-info-for-session session-key nil))))))))
diff --git a/test/metabase/session/task/session_cleanup_test.clj b/test/metabase/session/task/session_cleanup_test.clj
index 3fe227388bf..05758d39b90 100644
--- a/test/metabase/session/task/session_cleanup_test.clj
+++ b/test/metabase/session/task/session_cleanup_test.clj
@@ -23,3 +23,5 @@
(#'session-cleanup/cleanup-sessions!)
(is (not (t2/exists? :model/Session :id (:id old-session))))
(is (t2/exists? :model/Session :id (:id new-session)))))))
+
+;; cleanup-idle-sessions-test is in metabase-enterprise.api.session-test because it requires EE features.