Package dyntabs.ai.activity

Class InMemoryActivityStore

java.lang.Object
dyntabs.ai.activity.InMemoryActivityStore
All Implemented Interfaces:
ActivityStore
@ApplicationScoped @Default @Priority(1000) public class InMemoryActivityStore extends Object implements ActivityStore
The default ActivityStore: a process-local, bounded, per-session ring-buffer that keeps only the most recent slice of activity and forgets everything when the process stops.

What this class is for

This is the v1 storage decision made concrete. The Ambient Activity feature only ever reads a recent window of events to inject into a prompt, so it does not need durable storage — and keeping activity in memory is also the most privacy-friendly default, since it evaporates with the session rather than accumulating on disk. Each session gets its own fixed-capacity buffer; once full, the oldest event is evicted to make room for the newest, so memory use is bounded no matter how long a user works.

Familiar analogy: a whiteboard by someone's desk that only fits twenty lines. They jot what they're doing as they go; when the board fills up, the top line gets wiped to write a new one at the bottom. You can always read the last twenty things at a glance, but there is no filing cabinet — wipe the board (end the session) and the history is gone. That ephemerality is a feature here, not a limitation.

Why per-session buffers

Partitioning by session keeps one user's recent activity bounded independently of everyone else's, and makes the common "recent in this session/tab" read cheap — we scan one small buffer, not a global log. Combined with TabForge's @TabScoped model, this is what gives per-tab working memory essentially for free.

Thread-safety

record(dyntabs.ai.activity.UserActivityEvent) runs on user request threads; query(dyntabs.ai.activity.ActivityQuery) may run on another thread when the assistant is invoked. The per-session buffers live in a ConcurrentHashMap, and every read or write of an individual buffer is guarded by synchronizing on that buffer. Snapshots are copied out under the lock and filtered outside it, so a query never blocks recording for longer than a quick array copy.

Registered as the Default ActivityStore with a low (library-default) priority, so an application can override it simply by providing its own enabled alternative.

See Also:

  • Field Details

    • DEFAULT_CAPACITY_PER_SESSION

      public static final int DEFAULT_CAPACITY_PER_SESSION
      Default number of events retained per session before the oldest is evicted.
      See Also:

  • Constructor Details

    • InMemoryActivityStore

      public InMemoryActivityStore()
      Create a store with the default per-session capacity.

    • InMemoryActivityStore

      public InMemoryActivityStore(int capacityPerSession)
      Create a store with an explicit per-session capacity (handy for tests).
      Parameters:
      capacityPerSession - the maximum events retained per session; must be positive

  • Method Details

    • record

      public void record(UserActivityEvent event)
      Description copied from interface: ActivityStore
      Append one event to the timeline.

      Implementations should treat this as best-effort and non-throwing: it runs on the user's request thread, and recording is never more important than the action being recorded.

      Specified by:
      record in interface ActivityStore
      Parameters:
      event - the event to store; must not be null

    • query

      public List<UserActivityEvent> query(ActivityQuery query)
      Description copied from interface: ActivityStore
      Return the events matching the given query, oldest first, capped by the query's limit.
      Specified by:
      query in interface ActivityStore
      Parameters:
      query - the filter describing which slice to return; must not be null
      Returns:
      a chronological, caller-owned snapshot list; never null (empty if nothing matches)