fix(cloudflare): use correct Proxy receiver in instrumentDurableObjectStorage (#19662)

## Summary

Fixes #19661

`instrumentDurableObjectStorage`'s Proxy `get` trap passes `receiver`
(the proxy) to `Reflect.get`, breaking native workerd getters like
`storage.sql` that validate `this` via internal slots.

- Change `Reflect.get(target, prop, receiver)` → `Reflect.get(target,
prop, target)` so native getters execute with the real storage object as
`this`
- Add regression tests using a class with private fields to simulate
workerd's native brand-checked getters

## Details

The `sql` property on `DurableObjectStorage` is a native getter that
requires the real native object as `this`. When the Proxy's `get` trap
calls `Reflect.get(target, prop, receiver)`, the getter runs with `this`
= proxy → "Illegal invocation". Using `target` as receiver ensures
native getters always run against the real storage object.

Instrumented KV methods (`get`, `put`, `delete`, `list`) were unaffected
because they're functions that get explicitly `.bind(target)`ed or
called via `.apply(target, args)`. The bug only manifests for
non-function getters (like `sql`).

**Regression tests** use a `BrandCheckedStorage` class with private
fields — accessing `#sqlInstance` on the wrong `this` throws TypeError,
faithfully simulating workerd's native internal-slot validation.

---------

Co-authored-by: Nicolas Hrubec <nico.hrubec@sentry.io>

Author: dmmulroy

packages/cloudflare/src/instrumentations/instrumentDurableObjectStorage.ts

@@ -16,8 +16,13 @@ type StorageMethod = (typeof STORAGE_METHODS_TO_INSTRUMENT)[number];
  */
 export function instrumentDurableObjectStorage(storage: DurableObjectStorage): DurableObjectStorage {
   return new Proxy(storage, {
-    get(target, prop, receiver) {
-      const original = Reflect.get(target, prop, receiver);
+    get(target, prop, _receiver) {
+      // Use `target` as the receiver instead of the proxy (`_receiver`).
+      // Native workerd getters (e.g., `storage.sql`) validate `this` via
+      // internal slots. Passing the proxy as receiver breaks that check,
+      // causing "Illegal invocation: function called with incorrect `this`
+      // reference" errors.
+      const original = Reflect.get(target, prop, target);
 
       if (typeof original !== 'function') {
         return original;

packages/cloudflare/test/instrumentDurableObjectStorage.test.ts

@@ -182,6 +182,25 @@ describe('instrumentDurableObjectStorage', () => {
     });
   });
 
+  describe('native getter preservation', () => {
+    it('preserves native getter `this` binding through the proxy', () => {
+      // Private fields simulate workerd's native brand check —
+      // accessing #sqlInstance on wrong `this` throws TypeError,
+      // like workerd's "Illegal invocation".
+      class BrandCheckedStorage {
+        #sqlInstance = { exec: () => {} };
+        get sql() {
+          return this.#sqlInstance;
+        }
+      }
+
+      const storage = new BrandCheckedStorage();
+      const instrumented = instrumentDurableObjectStorage(storage as any);
+
+      expect(() => (instrumented as any).sql).not.toThrow();
+    });
+  });
+
   describe('error handling', () => {
     it('propagates errors from storage operations', async () => {
       const mockStorage = createMockStorage();