session/redis: fix linter and add tests (#374)

- Introduced TestService_AsyncPersisterNum_DefaultClamp to verify
default clamp behavior for async persister number.
- Added TestService_AppendEvent_NoPanic_AfterClose to ensure AppendEvent
does not panic after service closure.
- Implemented TestService_SessionEventLimit_TrimsOldest to confirm that
only the latest events are retained when exceeding the session event
limit.
- Updated AppendEvent method to handle event channel indexing more
robustly and added context cancellation in async worker.

Author: Rememorio

session/redis/redis_session_service.go

@@ -417,7 +417,8 @@ func (s *Service) AppendEvent(
 
 		// TODO: Init hash index at session creation to prevent duplicate computation.
 		hKey := getEventKey(key)
-		index := murmur3.Sum32([]byte(hKey)) % uint32(len(s.eventPairChans))
+		n := len(s.eventPairChans)
+		index := int(murmur3.Sum32([]byte(hKey))) % n
 		select {
 		case s.eventPairChans[index] <- &sessionEventPair{key: key, event: event}:
 		case <-ctx.Done():
@@ -789,10 +790,11 @@ func (s *Service) startAsyncPersistWorker() {
 	for _, eventPairChan := range s.eventPairChans {
 		go func(eventPairChan chan *sessionEventPair) {
 			for eventPair := range eventPairChan {
-				ctx, _ := context.WithTimeout(context.Background(), defaultTimeout)
+				ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
 				if err := s.addEvent(ctx, eventPair.key, eventPair.event); err != nil {
 					log.Errorf("redis session service persistence event failed: %w", err)
 				}
+				cancel()
 			}
 		}(eventPairChan)
 	}

session/redis/redis_session_service_test.go

@@ -1030,6 +1030,86 @@ func TestService_UserStateTTL(t *testing.T) {
 	}
 }
 
+func TestService_AsyncPersisterNum_DefaultClamp(t *testing.T) {
+	redisURL, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	service, err := NewService(
+		WithRedisClientURL(redisURL),
+		WithEnableAsyncPersist(true),
+		WithAsyncPersisterNum(0),
+	)
+	require.NoError(t, err)
+	defer service.Close()
+
+	assert.Equal(t, defaultAsyncPersisterNum, len(service.eventPairChans))
+}
+
+func TestService_AppendEvent_NoPanic_AfterClose(t *testing.T) {
+	redisURL, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	service, err := NewService(
+		WithRedisClientURL(redisURL),
+		WithEnableAsyncPersist(true),
+		WithAsyncPersisterNum(2),
+	)
+	require.NoError(t, err)
+
+	// Create a session.
+	sessionKey := session.Key{
+		AppName:   "testapp",
+		UserID:    "user123",
+		SessionID: "session123",
+	}
+	sess, err := service.CreateSession(context.Background(), sessionKey, session.StateMap{})
+	require.NoError(t, err)
+
+	// Close service to close channels.
+	service.Close()
+
+	// Append after close should not panic due to recover in AppendEvent.
+	evt := createTestEvent("event-after-close", "agent", "msg", time.Now(), false)
+	assert.NotPanics(t, func() {
+		_ = service.AppendEvent(context.Background(), sess, evt)
+	})
+}
+
+func TestService_SessionEventLimit_TrimsOldest(t *testing.T) {
+	redisURL, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	limit := 3
+	service, err := NewService(
+		WithRedisClientURL(redisURL),
+		WithSessionEventLimit(limit),
+	)
+	require.NoError(t, err)
+	defer service.Close()
+
+	// Create session.
+	sessionKey := session.Key{AppName: "testapp", UserID: "user123", SessionID: "session123"}
+	sess, err := service.CreateSession(context.Background(), sessionKey, session.StateMap{})
+	require.NoError(t, err)
+
+	// Append 5 events with increasing timestamps.
+	base := time.Now().Add(-5 * time.Minute)
+	ids := []string{"e1", "e2", "e3", "e4", "e5"}
+	for i, id := range ids {
+		evt := createTestEvent(id, "agent", "content", base.Add(time.Duration(i)*time.Second), false)
+		err := service.AppendEvent(context.Background(), sess, evt, session.WithEventTime(evt.Timestamp))
+		require.NoError(t, err)
+	}
+
+	// Get session and verify only latest 'limit' events remain in chronological order.
+	got, err := service.GetSession(context.Background(), sessionKey, session.WithEventNum(0))
+	require.NoError(t, err)
+	require.NotNil(t, got)
+	require.Len(t, got.Events, limit)
+	// Should keep e3, e4, e5 in chronological order.
+	assert.Equal(t, []string{"e3", "e4", "e5"}, []string{got.Events[0].ID, got.Events[1].ID, got.Events[2].ID})
+}
+
 func TestEnsureEventStartWithUser(t *testing.T) {
 	tests := []struct {
 		name           string