revert(observability): drop the global-state normalization machinery

Reverts the previous two commits. They guarded a case that only arises when a
dev server's globalThis outlives a module evaluation across this change, where
the cost is a NaN in a diagnostic log locally — and the guard itself was worth
more risk than the thing it prevented, having briefly replaced the shared state
object and so allowed two module instances to each open their own connection.

Back to the original initialize-once block with the new fields added. The
global-state handling is now identical to staging apart from those additions.

Author: waleedlatif1

apps/sim/lib/billing/calculations/usage-reservation.test.ts

@@ -339,13 +339,6 @@ describe('usage-reservation', () => {
   })
 
   describe('refreshExecutionSlotExpiry', () => {
-    it('rethrows the original error object rather than the diagnostic wrapper', async () => {
-      const original = Object.assign(new Error('Command timed out'), { code: 'ETIMEDOUT' })
-      getMock.mockRejectedValueOnce(original)
-
-      await expect(refreshExecutionSlotExpiry('exec-1', Date.now() + 60_000)).rejects.toBe(original)
-    })
-
     it('refreshes only the locally owned slot and matching pointer', async () => {
       evalMock.mockResolvedValueOnce(1).mockResolvedValueOnce(1)
       await reserveExecutionSlot(memberParams)

apps/sim/lib/core/config/redis.test.ts

@@ -30,7 +30,6 @@ import {
   describeRedisConnection,
   extendLock,
   getRedisClient,
-  normalizeRedisState,
   onRedisReconnect,
   resetForTesting,
 } from '@/lib/core/config/redis'
@@ -226,66 +225,6 @@ describe('redis config', () => {
       expect(JSON.stringify(d)).not.toContain('10.0.0.5')
     })
 
-    it('never throws, so it cannot mask the error it is describing', () => {
-      // Called from catch blocks: a throw here would replace the real failure.
-      mockEnv.REDIS_URL = undefined
-      expect(() => describeRedisConnection()).not.toThrow()
-
-      mockEnv.REDIS_URL = 'not a url'
-      expect(() => describeRedisConnection()).not.toThrow()
-      expect(describeRedisConnection().hostKind).toBe('unknown')
-
-      // rediss:// to a bare IP with no REDIS_TLS_SERVERNAME makes the real
-      // getConfiguredRedisUrl path throw; the snapshot must still come back.
-      mockEnv.REDIS_URL = 'rediss://10.0.0.5:6379'
-      mockEnv.REDIS_TLS_SERVERNAME = undefined
-      expect(() => describeRedisConnection()).not.toThrow()
-    })
-
-    it('upgrades a state object that predates these fields instead of trusting its shape', () => {
-      // Exactly the shape the global held before this change.
-      const stale = {
-        client: null,
-        pingFailures: 0,
-        pingInterval: null,
-        pingInFlight: false,
-        reconnectListeners: [],
-      }
-
-      const normalized = normalizeRedisState(stale)
-
-      // Identity must survive: every module instance has to keep pointing at the
-      // same object, or two of them each open their own client.
-      expect(normalized).toBe(stale)
-
-      // Undefined slips past the `=== null` guards and yields NaN downstream.
-      expect(normalized.clientCreatedAt).toBeNull()
-      expect(normalized.lastReadyAt).toBeNull()
-      expect(normalized.lastPingOkAt).toBeNull()
-      expect(normalized.connects).toBe(0)
-      expect(normalized.reconnects).toBe(0)
-      expect(normalized.errors).toBe(0)
-      expect(normalized.lastErrorMessage).toBeNull()
-      for (const [key, value] of Object.entries(normalized)) {
-        expect(value, `${key} is undefined`).not.toBeUndefined()
-      }
-    })
-
-    it('carries a running health check across normalization so it is not started twice', () => {
-      const interval = setInterval(() => {}, 1_000)
-      try {
-        expect(normalizeRedisState({ pingInterval: interval }).pingInterval).toBe(interval)
-      } finally {
-        clearInterval(interval)
-      }
-    })
-
-    it('preserves accumulated counters when the shape is already current', () => {
-      const normalized = normalizeRedisState({ connects: 4, reconnects: 2, errors: 7 })
-
-      expect(normalized).toMatchObject({ connects: 4, reconnects: 2, errors: 7 })
-    })
-
     it('does not date a connection that has been discarded', async () => {
       mockRedisInstance.status = 'ready'
       getRedisClient()

apps/sim/lib/core/config/redis.ts

@@ -69,43 +69,24 @@ interface RedisState {
   lastErrorMessage: string | null
 }
 
-const g = globalThis as typeof globalThis & { _redisState?: Partial<RedisState> }
-
-/**
-Backfilled in place, because the global outlives a module evaluation in two
- * directions at once.
- *
- * A state object created before any of these fields existed keeps them
- * `undefined`, which slips past the `=== null` guards below and turns every age
- * into `now - undefined` and every counter into `undefined++` — NaN in both
- * cases, serialized as `null`, in the one payload whose purpose is being
- * trustworthy. So the shape has to be upgraded rather than trusted.
- *
- * It must be upgraded *without replacing the object*. Sharing one object across
- * evaluations is the entire reason this lives on `globalThis`: assigning a fresh
- * one leaves an earlier module instance holding the previous object, and two
- * instances that disagree about `client` each open their own connection and
- * start their own health check. Mutating in place keeps every holder pointing at
- * the same state while still filling in what an older shape lacks.
- */
-export function normalizeRedisState(existing: Partial<RedisState>): RedisState {
-  existing.client ??= null
-  existing.pingFailures ??= 0
-  existing.pingInterval ??= null
-  existing.pingInFlight ??= false
-  existing.reconnectListeners ??= []
-  existing.clientCreatedAt ??= null
-  existing.lastReadyAt ??= null
-  existing.lastPingOkAt ??= null
-  existing.connects ??= 0
-  existing.reconnects ??= 0
-  existing.errors ??= 0
-  existing.lastErrorMessage ??= null
-  return existing as RedisState
+const g = globalThis as typeof globalThis & { _redisState?: RedisState }
+if (!g._redisState) {
+  g._redisState = {
+    client: null,
+    pingFailures: 0,
+    pingInterval: null,
+    pingInFlight: false,
+    reconnectListeners: [],
+    clientCreatedAt: null,
+    lastReadyAt: null,
+    lastPingOkAt: null,
+    connects: 0,
+    reconnects: 0,
+    errors: 0,
+    lastErrorMessage: null,
+  }
 }
-
-g._redisState ??= {}
-const state = normalizeRedisState(g._redisState)
+const state = g._redisState
 
 /**
  * A command that never gets a reply fails identically whichever of three states