as: Use read-only client for webhook List without pagination

Avoid using Watch() for non-paginated List() calls in the webhook
registry. Watch() holds a Redis connection for the entire transaction
duration, which contributes to connection spikes during high traffic.

When pagination is not required (the common case for handleUp), we now
use ReadOnlyClient() directly, matching the pattern used in other
registries (packages/redis, pubsub/redis).

Author: nicholaspcr

CHANGELOG.md

@@ -28,6 +28,10 @@ For details about compatibility between different releases, see the **Commitment
 - Add HSTS response headers.
 - Draft band definition for Uzbekistan 923Mhz band.
 
+### Fixed
+
+- Application Server webhook registry now uses read-only Redis client for non-paginated list operations, reducing connection holding time during high traffic.
+
 ## [3.35.1] - 2025-12-19
 
 ## [3.35.0] - 2025-11-19

pkg/applicationserver/io/web/redis/registry.go

@@ -102,16 +102,19 @@ func (r WebhookRegistry) List(ctx context.Context, ids *ttnpb.ApplicationIdentif
 	appUID := unique.ID(ctx, ids)
 	uidKey := r.appKey(appUID)
 
-	opts := []ttnredis.FindProtosOption{}
+	defer trace.StartRegion(ctx, "list webhooks by application id").End()
+
 	limit, offset := ttnredis.PaginationLimitAndOffsetFromContext(ctx)
-	if limit != 0 {
-		opts = append(opts,
-			ttnredis.FindProtosSorted(true),
-			ttnredis.FindProtosWithOffsetAndCount(offset, limit),
-		)
-	}
 
 	rangeProtos := func(c redis.Cmdable) error {
+		var opts []ttnredis.FindProtosOption
+		if limit != 0 {
+			opts = append(opts,
+				ttnredis.FindProtosSorted(true),
+				ttnredis.FindProtosWithOffsetAndCount(offset, limit),
+			)
+		}
+		pbs = make([]*ttnpb.ApplicationWebhook, 0)
 		return ttnredis.FindProtos(ctx, c, uidKey, r.makeIDKeyFunc(appUID), opts...).Range(
 			func() (proto.Message, func() (bool, error)) {
 				pb := &ttnpb.ApplicationWebhook{}
@@ -126,27 +129,21 @@ func (r WebhookRegistry) List(ctx context.Context, ids *ttnpb.ApplicationIdentif
 			})
 	}
 
-	defer trace.StartRegion(ctx, "list webhooks by application id").End()
-
 	var err error
 	if limit != 0 {
-		var lockerID string
-		lockerID, err = ttnredis.GenerateLockerID()
-		if err != nil {
-			return nil, err
-		}
-		err = ttnredis.LockedWatch(ctx, r.Redis, uidKey, lockerID, r.LockTTL, func(tx *redis.Tx) (err error) {
+		// Pagination requires Watch() for consistency between SCard and SORT.
+		err = r.Redis.Watch(ctx, func(tx *redis.Tx) error {
 			total, err := tx.SCard(ctx, uidKey).Result()
 			if err != nil {
 				return err
 			}
 			ttnredis.SetPaginationTotal(ctx, total)
 			return rangeProtos(tx)
-		})
+		}, uidKey)
 	} else {
+		// No pagination - use client without Watch() to reduce connection holding time.
 		err = rangeProtos(r.Redis)
 	}
-
 	if err != nil {
 		return nil, ttnredis.ConvertError(err)
 	}

pkg/applicationserver/io/web/redis/registry_test.go

@@ -179,6 +179,42 @@ func TestWebhookRegistry(t *testing.T) {
 		a.So(webhooks[0].Format, should.Equal, format)
 	})
 
+	t.Run("ListMultipleWithoutPagination", func(t *testing.T) {
+		t.Parallel()
+		a, ctx := test.New(t)
+
+		appID := &ttnpb.ApplicationIdentifiers{
+			ApplicationId: "myapp-list-multiple",
+		}
+
+		// Create multiple webhooks
+		for i := 1; i <= 5; i++ {
+			whIDs := &ttnpb.ApplicationWebhookIdentifiers{
+				ApplicationIds: appID,
+				WebhookId:      fmt.Sprintf("webhook-%02d", i),
+			}
+			_, err := registry.Set(ctx, whIDs, paths,
+				func(*ttnpb.ApplicationWebhook) (*ttnpb.ApplicationWebhook, []string, error) {
+					return &ttnpb.ApplicationWebhook{
+						Ids:     whIDs,
+						Format:  format,
+						BaseUrl: baseURL,
+					}, paths, nil
+				},
+			)
+			a.So(err, should.BeNil)
+		}
+
+		// List without pagination context - exercises ReadOnlyClient() path
+		webhooks, err := registry.List(ctx, appID, paths)
+		a.So(err, should.BeNil)
+		a.So(webhooks, should.HaveLength, 5)
+		for _, wh := range webhooks {
+			a.So(wh.Ids.ApplicationIds, should.Resemble, appID)
+			a.So(wh.Format, should.Equal, format)
+		}
+	})
+
 	t.Run("Pagination", func(t *testing.T) {
 		t.Parallel()
 		a, ctx := test.New(t)