Skip to main content

Overview

tif1 implements a multi-tier caching architecture that reduces redundant network requests. The SQLite-backed Cache consists of:
  1. Parsed-object LRUs: Decoded JSON payloads (128 items) and telemetry payloads (256 items); fixed size
  2. Blob LRUs: Serialized JSON bytes (1024 items) and telemetry bytes (2048 items); sized by memory_cache_max_items and memory_telemetry_cache_max_items
  3. SQLite payload tables: Durable cache and telemetry_cache tables that survive across processes
  4. SQLite frame tiers: Materialized telemetry DataFrames and the processed laps DataFrame of a session. Pandas telemetry frames live in telemetry_frames_drv, one typed-columnar row per driver. telemetry_frames holds per-lap pandas rows from earlier releases, and frames with a column outside the telemetry dtype contract. Polars telemetry frames live in telemetry_frames_pl_ipc, one Arrow IPC row per driver. telemetry_frames_pl holds per-lap polars rows from earlier releases, and rows for drivers whose laps have different schemas. The laps DataFrame lives in laps_frames / laps_frames_pl. Both tiers derive from the payload tables, and the loader rebuilds missing rows. SQLite’s PRAGMA user_version versions the telemetry frame tables (_FRAME_TIER_SCHEMA_VERSION, now 1). A cache file with an older version drops these two tables once
  5. Negative-verdict tier: The missing_payloads table remembers payloads that every CDN reported missing, for missing_payloads_ttl_days (default 7 days)
The cache table also holds one TTL-scoped row per live season, f1schedule/schedule_{year}.json, written by tif1.events. After schedule_ttl_hours (default 6) the stale row is still served, and a background thread fetches the new file. Two more tiers live outside Cache: the per-session SessionMemo (Session._memo) and the process-global backend lap LRU (get_backend_lap_cache). Hot data comes from memory (microsecond latency). Cold data comes from disk (millisecond latency) instead of a network request (latency of a second or more). The cache is thread-safe and supports synchronous and asynchronous operations.
tif1.Cache (the exported name) is the FastF1-compatible helper class in tif1.fastf1_compat. tif1.get_cache() returns the SQLite-backed tif1.cache.Cache that this page documents.

Cache Architecture

The cache stores two primary types of data:
  • JSON Data: Session metadata, lap data, driver information, weather data, and race control messages in a key-value table
  • Telemetry Data: High-frequency sensor data (speed, throttle, brake, gear, RPM, DRS). Stored in the dedicated telemetry_cache table with a composite primary key on (year, gp, session, driver, lap)
With enable_cache on (the default), Session.load() caches all data that it fetches. The Cache API gives manual control.

Getting the Cache Instance

get_cache()

Returns the global singleton Cache instance used throughout the library. This is the primary entry point for all cache operations. The cache is initialized lazily on first access and configured based on environment variables and .tif1rc settings. The same instance is shared across all sessions and operations in the application. Returns: Cache - The global cache singleton Thread Safety: The cache instance is thread-safe and can be safely accessed from multiple threads. Example:
Configuration: The cache behavior can be customized through environment variables. The Cache reads all of them except TIF1_ENABLE_CACHE when it is created (the first get_cache() call):
  • TIF1_CACHE_DIR: Custom cache directory (default: OS-dependent; see the platform defaults in the configuration reference)
  • TIF1_ENABLE_CACHE: Set to "false" so that sessions neither read nor write the cache
  • TIF1_MEMORY_CACHE_MAX_ITEMS / TIF1_MEMORY_TELEMETRY_CACHE_MAX_ITEMS: Size of the JSON and telemetry blob LRUs (defaults 1024 and 2048)
  • TIF1_MISSING_PAYLOADS_TTL_DAYS: Lifetime of all-CDN-missing verdicts in days (default 7.0)

Cache Management Operations

clear()

Removes all cached data from every in-memory tier and from the SQLite cache, telemetry_cache, telemetry_frames_drv, telemetry_frames, telemetry_frames_pl, telemetry_frames_pl_ipc, laps_frames, laps_frames_pl, and missing_payloads tables. This operation is irreversible and forces all later data requests to fetch from the CDN. Use Cases:
  • Clearing corrupted cache data
  • Freeing disk space
  • Forcing a complete data refresh
  • Troubleshooting data inconsistencies
Performance Impact: After the cache is cleared, the first load of any session is slower. All data must be fetched from the network again. Example:
Advanced Usage:

invalidate()

Invalidates cached data by scope. This is the only selective invalidation API; prefer it over raw SQL against cache.sqlite. Parameters:
  • scope ("all" | "memory" | "json" | "telemetry"): The tier to drop
    • "all" - Every tier, memory and SQLite; equivalent to clear()
    • "memory" - Only the four in-memory LRU tiers and the in-memory verdict mirror; SQLite rows persist
    • "json" - The JSON payload tier: the cache table, missing_payloads, the derived laps_frames / laps_frames_pl rows, and the JSON LRUs
    • "telemetry" - The telemetry tier: telemetry_cache, telemetry_frames_drv, telemetry_frames, telemetry_frames_pl, telemetry_frames_pl_ipc, laps_frames / laps_frames_pl, missing_payloads, and the telemetry LRUs
Any other value raises ValueError. The method first joins pending background frame writers, so a late write cannot re-insert cleared rows. Example:

has_session_data()

Checks whether the cache contains any data for a specific session without actually loading it. The method URL-encodes gp and session first, then scans the JSON blob LRU for the {year}/{gp}/{session}/ prefix and the SQLite cache and telemetry_cache tables. On a probe error it returns True to keep cache reads enabled. Parameters:
  • year (int): Season year (for example, 2024, 2023)
  • gp (str): Grand Prix name, plain ("Monaco Grand Prix") or URL-encoded as held in session.gp ("Monaco%20Grand%20Prix")
  • session (str): Session name, plain ("Practice 1") or URL-encoded as held in session.session ("Race", "Qualifying", "Practice%201", "Sprint%20Qualifying")
Only has_session_data() normalizes its arguments. The cache keys themselves use the URL-encoded names of the CDN paths, so get(), get_telemetry() and the batch readers need the encoded form (session.gp, session.session). A snake_case name such as "Monaco_Grand_Prix" matches nothing in either method.
Returns: bool - True if any JSON or telemetry data exists for the session, False otherwise Use Cases:
  • Checking cache availability before loading
  • Building cache status dashboards
  • Implementing cache warming strategies
  • Conditional data loading logic
Example:
Batch Checking:

close()

Explicitly closes the SQLite database connection and releases associated resources. For the get_cache() singleton, an atexit handler runs it when the Python process exits. A private Cache() instance also closes when it is garbage-collected. Invoke it manually for fine-grained resource management. When to Use:
  • Releasing the SQLite handle of a separate Cache() instance after maintenance work
  • Testing scenarios that build and discard throwaway Cache() instances
Note: close() sets the connection to None and clears every in-memory tier. There is no reconnect: every later read returns None and every later write is a no-op. Do not close the singleton from get_cache() before the process exits; the atexit handler closes it. For maintenance work, construct a separate Cache(cache_dir) instance and close that one. Example:
Private Instance Pattern:

General Cache Access (JSON Data)

These methods provide low-level access to the cache’s key-value store for JSON-serializable data. Most users will not need these methods directly, as Session.load() handles caching automatically. However, they are useful for advanced use cases like custom data pipelines or cache inspection.

get()

Retrieves cached JSON-serializable data for a specific key. Checks the parsed-object LRU, then the blob LRU, then SQLite. Parameters:
  • key (str): Cache key in the format "{year}/{gp}/{session}/{path}" where path is the CDN payload path, for example:
    • drivers.json - Driver list and metadata
    • session_laptimes.json - Session lap times
    • rcm.json - Race control messages
    • weather.json - Weather conditions
    • corners.json - Circuit corner markers
    • {driver}/laptimes.json - Per-driver lap times
    • {driver}/{lap}_tel.json - Per-lap telemetry payload
Returns: Any | None - The cached data (typically a dict or list), or None if not found Example:
Advanced Usage - Cache Inspection:

set()

Stores JSON-serializable data in the cache with the specified key. Updates the blob LRU and the persistent SQLite database, and drops any stale parsed-object entry. Parameters:
  • key (str): Cache key in the format "{year}/{gp}/{session}/{path}"
  • data (Any): JSON-serializable data to cache (dict, list, str, int, float, bool, None)
Serialization: Data is serialized with orjson for performance. Ensure that the data contains only JSON-compatible types. Compression: Serialized rows of 4096 bytes or more are compressed at the SQLite boundary with zstd level 1. Without a zstd binding, zlib level 3 is used. The in-memory LRU keeps the plain bytes. Example:
Bulk Caching:

set_raw()

Stores an already-serialized JSON blob without re-encoding. The async fetch pipeline uses this when validation left the payload byte-identical to the HTTP body. Blobs of 4 KB or larger are compressed with zstd level 1 at the SQLite boundary only. Legacy zlib rows stay readable via magic-byte detection. The in-memory LRU keeps the plain blob. Small rows stay plain TEXT, the legacy storage shape. Python 3.14+ uses the standard-library compression.zstd binding and 3.11-3.13 use the zstandard package; both write identical frames. Parameters:
  • key (str): Cache key in the format "{year}/{gp}/{session}/{path}"
  • blob (bytes | bytearray | memoryview): UTF-8 JSON bytes
Example:

Telemetry Cache Access

Telemetry data (high-frequency sensor readings) lives in the dedicated telemetry_cache SQLite table, optimized for lap-by-lap queries. This separation improves performance for telemetry-heavy workloads and enables efficient batch operations.

Telemetry Data Structure

Each telemetry entry is the raw CDN payload of a single lap: a dict of parallel lists with lowercase keys.
  • time - Seconds from the start of the lap
  • speed - Vehicle speed in km/h
  • rpm - Engine revolutions per minute
  • gear - Current gear (0-8, where 0 is neutral)
  • throttle - Throttle position (0-100%)
  • brake - Brake applied (0 or 1)
  • drs - DRS flag (0=closed, 1=open)
  • distance, rel_distance - Distance in meters and as a fraction of the lap
  • acc_x, acc_y, acc_z - Accelerations
  • x, y, z - 3D position coordinates
  • DriverAhead, DistanceToDriverAhead - Car ahead and the gap to it
  • dataKey - A string label of the lap (for example "2024-Monaco Grand Prix-Race-ALB-1"), not a list
Telemetry frames rename these keys (Time, Speed, nGear, …). The raw payload keeps the lowercase names.

get_telemetry()

Retrieves telemetry data for a specific driver’s lap. Returns None if the telemetry is not cached. Parameters:
  • year (int): Season year (for example, 2024)
  • gp (str): URL-encoded Grand Prix name, as in session.gp (for example, "Monaco%20Grand%20Prix")
  • session (str): URL-encoded session name, as in session.session (for example, "Race", "Practice%201")
  • driver (str): Three-letter driver code (for example, "VER", "HAM", "LEC")
  • lap (int): Lap number (1-indexed)
Returns: Any | None - Telemetry data structure (typically a dict with arrays), or None if not found Performance: Single telemetry lookup is optimized with a composite index on (year, gp, session, driver, lap). Example:
Analyzing Cached Telemetry:

set_telemetry()

Stores telemetry data for a specific driver’s lap in the telemetry blob LRU and the telemetry_cache table. Parameters:
  • year (int): Season year
  • gp (str): Grand Prix identifier
  • session (str): Session type
  • driver (str): Three-letter driver code
  • lap (int): Lap number
  • data (Any): Telemetry data structure to cache
Serialization: Data is serialized using orjson before storage. Compression: Serialized rows of 4096 bytes or more are compressed at the SQLite boundary (zstd level 1), as for set().
set_telemetry() overwrites the cached payload for that lap, and tif1 later reads it as real telemetry. Write only complete payloads in the CDN format, or use a session identity that no real session uses.
Example:

get_telemetry_batch()

Retrieves multiple telemetry entries in a single optimized batch query. This is more efficient than calling get_telemetry() multiple times, as it uses a single SQL query with an IN clause. Parameters:
  • year (int): Season year
  • gp (str): Grand Prix identifier
  • session (str): Session type
  • driver_laps (list[tuple[str, int]]): List of (driver_code, lap_number) tuples to fetch
Returns: dict[tuple[str, int], Any] - Dictionary mapping (driver, lap) tuples to telemetry data. Missing entries are not included in the result. Performance Benefits:
  • Single database query instead of N queries
  • Reduced Python-SQLite round trips
  • Optimized for bulk telemetry analysis
  • Ideal for comparing multiple drivers/laps
Example - Basic Batch Fetch:
Example - Comparing Driver Performance:
Example - Fastest Lap Analysis:

get_telemetry_frames_batch()

Batch-reads materialized telemetry DataFrames from the frame tier. Pandas frames come from telemetry_frames_drv, one typed-columnar blob per driver. The blob holds the raw bytes of every block over all laps of the driver, behind a small header, compressed with lz4 (zstd as fallback). Each lap frame is a set of views into the driver’s arrays, built without the DataFrame constructor. Refs not found there fall back to the per-lap telemetry_frames rows (typed-columnar or pickle, written by earlier releases). When a session serves 32 or more laps that way, a background thread rewrites them as driver rows. Polars frames come from telemetry_frames_pl_ipc, one Arrow IPC blob per driver with the lap boundaries alongside. A lap is a slice of the driver frame. Refs not found there fall back to the per-lap telemetry_frames_pl rows. The method never returns rows from the other backend. Refs without a frame row, or with a corrupt row, are absent from the result. They fall through to the payload tier. Parameters:
  • year, gp, session: Session identity, as for get_telemetry_batch()
  • driver_laps (list[tuple[str, int]]): (driver, lap) refs to read
  • lib ("pandas" or "polars"): Backend whose frame table to read
  • whole_driver (bool): pandas only. Also return the other laps stored in each driver row the batch touches. The session memoizes them, so the next lap of that driver is a memo hit.
  • frame_class (type or None): pandas only. DataFrame subclass to build, for example Telemetry. Its _metadata attributes start as None.
Returns: dict[tuple[str, int], Any] - (driver, lap) to DataFrame; empty when the connection is closed or no frame codec is available

get_driver_merged_frame()

Builds one pandas frame that holds laps back to back, in the given order, from the driver’s telemetry_frames_drv row. Laps.telemetry uses it for a single driver. Each run of laps stored consecutively in one layout group is a slice of the group arrays; several runs are concatenated. Returns None when the tier has no row for the driver, the row cannot be read, or a lap is not stored in it. The caller then concatenates per-lap frames.

set_telemetry_frames_batch()

Persists assembled telemetry frames in one bulk write. The payload tier stays the source of truth: frames are derived data. Pandas frames whose columns all have the telemetry contract’s dtypes are grouped per driver. Each group is merged with the laps already stored for that driver and written as one typed-columnar driver row. Per-lap rows of the laps now covered by the driver row are deleted. Any other frame is pickled into the per-lap table. Polars frames are grouped per driver and merged with the laps already stored for that driver. Each driver is written as one Arrow IPC row. A driver whose laps have different schemas falls back to per-lap pickle rows. Parameters:
  • frames (list[tuple[str, int, Any]]): (driver, lap, DataFrame) tuples to persist
  • lib ("pandas" or "polars"): Backend whose frame table to write
Returns: int - Number of frames written; 0 when the tier is unavailable

get_laps_frame() / set_laps_frame()

The laps frame tier: one processed laps DataFrame per (year, gp, session) and backend, stored in laps_frames (pandas) or laps_frames_pl (polars) with the same pickle-and-compress format as the telemetry frames. get_laps_frame() returns the DataFrame, or None on a miss, a corrupt row, or a row written by the other backend. set_laps_frame() returns 1 when the row was written and 0 when the tier is unavailable. invalidate("json"), invalidate("telemetry") and clear() drop these rows; the loader rebuilds them from the payloads.

Negative-Verdict Tier

When every CDN returns a 4xx other than 408 or 429 for a payload, the loader records the key in the missing_payloads table. Later loads skip the network probe for that key until the verdict expires. The lifetime is missing_payloads_ttl_days (TIF1_MISSING_PAYLOADS_TTL_DAYS, default 7.0). The verdicts load lazily from SQLite once per process.

is_known_missing()

Returns True when key has an unexpired all-CDN-missing verdict. Keys use the JSON-tier format "{year}/{gp}/{session}/{path}", also for telemetry paths. An expired verdict is discarded on read and returns False.

record_missing()

Records an all-CDN-missing verdict for key with the current timestamp, in memory and in SQLite. A later set() for the same key removes the verdict from memory and from SQLite.

discard_missing()

Removes the verdict for key from memory and SQLite, so the next load probes the CDNs again. Example:

Async Methods

The main read and write methods have async variants for use in async contexts. These methods enable high-performance async applications to interact with the cache without blocking the event loop.

Async Method Overview

Implementation Details

Async methods use loop.run_in_executor(None, ...) to run the synchronous SQLite operations in the default thread pool. This keeps the event loop free and preserves the thread safety of the sync methods.

get_async()

Asynchronously retrieves cached JSON data for a specific key. Example:

set_async()

Asynchronously stores JSON data in the cache. Example:

get_telemetry_async()

Asynchronously retrieves telemetry data for a specific driver’s lap. Example:

set_telemetry_async()

Asynchronously stores telemetry data for a specific driver’s lap. Example:

get_telemetry_batch_async()

Asynchronously retrieves multiple telemetry entries in a single optimized batch query. Example - Parallel Telemetry Fetching:
Example - High-Performance Data Pipeline:

Cache Instance Attributes

The Cache instance exposes several attributes for inspecting cache configuration and state.

cache_dir

The directory where the cache database and related files are stored. By default, tif1 follows FastF1’s OS-specific layout: Windows %LOCALAPPDATA%/Temp/tif1, macOS ~/Library/Caches/tif1, and Linux/other POSIX ~/.cache/tif1 when ~/.cache exists (otherwise ~/.tif1). It can be customized via TIF1_CACHE_DIR or .tif1rc. Example:

db_path

The full filesystem path to the SQLite database file (cache.sqlite). This file contains all persistent cache data. Use Cases:
  • Backing up the cache database
  • Checking database file size
  • Manually inspecting cache with SQLite tools
Example:

read_only

A hard-coded False attribute. No configuration option or environment variable sets it, so the cache is always writable. Write methods check it internally, but there is no supported read-only mode.

Module-Level Cache API

Besides the Cache class, tif1.cache exposes the building blocks of the memory tiers.

LRUCache

The default maxsize is MAX_CACHE_SIZE (100) from tif1.core_utils.constants; the Cache tiers pass their own configured limits. Thread-safe bounded LRU cache. It is the single LRU implementation backing the Cache in-memory tiers and the process-global backend lap caches. Reads support a lock-free fast path (get(key, ordered=False)); writes refresh LRU order and evict oldest-first at maxsize. Methods: get(key, *, ordered=True), set(key, value), clear(), pop(key, default=None), plus in, len(), and iteration support.

get_backend_lap_cache

Return the process-global lap cache for the given backend, keyed by "{year}_{gp}_{session}_laps". One cache per backend; shared across sessions in the same process.

clear_lap_cache

Clear both process-global backend lap caches (pandas and polars).

Cache.get_entry / Cache.set_entry

Unified kind-based access to the memory tiers and SQLite. CacheKind is "json" (a str path key) or "telemetry" (a (year, gp, session, driver, lap) tuple key). get()/set() and get_telemetry()/set_telemetry() are thin wrappers over these. Any other kind raises ValueError. The kinds "telemetry_payload" and "telemetry_df" belong to SessionMemo, not to Cache.

SessionMemo

Per-session memo tier held as Session._memo. It consolidates the session-scoped caches behind the same kind-based interface. It also owns the fastest-lap-reference memo, the persistent-cache probe result (has_session_data), and per-driver telemetry failure tracking. Not internally synchronized. The owning session’s access patterns are single-threaded per event loop.

Cache Statistics and Monitoring

The Cache class does not expose built-in statistics methods. Query the SQLite database directly for monitoring purposes. The payload tables are cache and telemetry_cache; the derived tables are telemetry_frames_drv, telemetry_frames, telemetry_frames_pl, telemetry_frames_pl_ipc, laps_frames, laps_frames_pl, and missing_payloads.

Example - Cache Size Analysis

Example - Session Coverage Report


Performance Considerations

Cache Hit Rates

The cache is most effective when:
  • Loading the same session multiple times
  • Analyzing historical data that does not change
  • Working with telemetry-heavy workloads
  • Running batch analyses across multiple sessions

Memory Management

Each in-memory LRU tier has a size limit to prevent excessive memory usage. The blob tiers default to 1024 JSON and 2048 telemetry items (memory_cache_max_items, memory_telemetry_cache_max_items). The parsed-object tiers are fixed at 128 and 256 items. A full tier evicts its least-recently-used entries (they remain in SQLite).

Disk Space

The SQLite database grows as more data is cached. A session with full telemetry adds one telemetry_cache row per driver lap, plus the derived frame rows. Telemetry takes most of the file size. Disk Space Management:

Optimization Tips

  1. Use Batch Operations: get_telemetry_batch() is faster than multiple get_telemetry() calls
  2. Selective Loading: Only load the data that is needed (for example, session.load(laps=True, telemetry=False))
  3. Async for Concurrency: Use the async methods to read the cache from async code without blocking the event loop
  4. Cache Warming: Pre-load frequently accessed sessions during off-peak hours
  5. Selective Invalidation: Use cache.invalidate("telemetry") to drop the telemetry payloads and derived frames while the JSON payloads stay cached
Example - Cache Warming Script:

Common Use Cases

Use Case 1: Cache Status Dashboard

Use Case 2: Selective Cache Clearing

Prefer cache.invalidate(scope) over raw SQL. It clears the matching memory tiers and the derived SQLite rows together.
invalidate() has no per-session scope. A per-session purge needs raw SQL and must cover the derived tables too. Otherwise telemetry_frames_drv, telemetry_frames, telemetry_frames_pl, telemetry_frames_pl_ipc, laps_frames, laps_frames_pl, and missing_payloads keep stale rows for the session.
Run this only when no Cache writer is active in the process. The singleton batches writes and commits every cache_commit_interval operations, so a second connection can hit database is locked while a batch is open. Run the purge from a dedicated maintenance process after every tif1 process that writes to the cache has exited. Do not close the global singleton in a process that keeps using tif1. close() is final and disables caching for the rest of that process.
A process that already holds the singleton keeps the session in its LRU tiers. In that process, call tif1.get_cache().invalidate("memory") after the purge. invalidate("memory") also drops the in-memory mirror of the verdicts, and the next probe reloads them from SQLite. Call cache.discard_missing(key) to delete one verdict outright.

Use Case 3: Cache Export/Import

Do not close the get_cache() singleton to copy the file: close() disables caching for the rest of the process. Run the copy from a separate process, or before the first get_cache() call, and resolve the path from the config. To restore a backup, copy it into a cache directory that no running tif1 process has open. Use a fresh directory, or the real one after every tif1 process exited. Then point TIF1_CACHE_DIR at it.
The database runs in WAL mode, so a live writer may hold pending pages in cache.sqlite-wal. Copy the file only while no tif1 process uses the cache.

Use Case 4: Cache Validation


Caching Strategy

Cache architecture

Config

Cache configuration

Performance

Optimization

Troubleshooting

Cache Not Working

Symptoms: Data is fetched from CDN every time, even for previously loaded sessions. Solutions:
  1. Check if caching is enabled:
  2. Verify cache directory is writable:
  3. Check environment variables:

Database Locked Errors

Symptoms: sqlite3.OperationalError: database is locked Causes:
  • Multiple processes accessing the cache simultaneously
  • Long-running transactions
  • Improper connection handling
Solutions:
  1. Raise the SQLite busy timeout before the first get_cache() call:
  2. Avoid concurrent writes from multiple processes
  3. Give each writer process its own TIF1_CACHE_DIR for heavy parallel writes

Cache Corruption

Symptoms: Errors when reading cached data, invalid JSON, or database integrity errors. Solutions:
  1. Clear and rebuild the cache:
  2. Stop every tif1 process, then delete the database file and its WAL files manually (Linux default path):
  3. Verify database integrity:

High Memory Usage

Symptoms: Python process consuming excessive RAM. Causes:
  • Large in-memory LRU cache
  • Loading many sessions with telemetry
Solutions:
  1. Reduce the blob LRU sizes with TIF1_MEMORY_CACHE_MAX_ITEMS and TIF1_MEMORY_TELEMETRY_CACHE_MAX_ITEMS (or config.set() before the first get_cache() call)
  2. Load data selectively:
  3. Process data in batches:

Slow Cache Performance

Symptoms: Cache reads are slower than expected. Solutions:
  1. Use batch operations for telemetry:
  2. Optimize the database with VACUUM. Run it from a separate process while no tif1 process uses the cache:
  3. Check disk I/O performance:

Caching Strategy

Understand the multi-tier cache architecture.

Config API

Configure cache behavior and location.

Performance Guide

Optimization techniques and best practices.

Core API

Learn how sessions interact with the cache.
Last modified on October 28, 2026