@luvio/environments 0.96.0 → 0.98.0

package/dist/es/es2018/environments.js

@@ -1,4 +1,4 @@
-import { buildStaleWhileRevalidateImplementation, InMemoryStore } from '@luvio/engine';
+import { emitAdapterEvent, buildStaleWhileRevalidateImplementation, InMemoryStore } from '@luvio/engine';
 
 function isDeprecatedDurableStoreEntry(durableRecord) {
     if (durableRecord.expiration !== undefined) {
@@ -126,19 +126,25 @@ function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
  */
 function reviveSnapshot(baseEnvironment, durableStore, 
 // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
-unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
+unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics = { l2ReadCount: 0, l2ReadDuration: 0 }) {
     const { recordId, select, seenRecords, state } = unavailableSnapshot;
     // L2 can only revive Unfulfilled snapshots that have a selector since they have the
     // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
     if (state !== 'Unfulfilled' || select === undefined) {
-        return Promise.resolve(unavailableSnapshot);
+        return Promise.resolve({
+            snapshot: unavailableSnapshot,
+            metrics: reviveMetrics,
+        });
     }
     // in case L1 store changes/deallocs a record while we are doing the async read
     // we attempt to read all keys from L2 - so combine recordId with any seenRecords
     const keysToReviveSet = assign({ [recordId]: true }, seenRecords);
     const keysToRevive = keys(keysToReviveSet);
     const canonicalKeys = keysToRevive.map((x) => baseEnvironment.storeGetCanonicalKey(x));
+    const start = Date.now();
+    reviveMetrics.l2ReadCount++;
     return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
+        reviveMetrics.l2ReadDuration += Date.now() - start;
         const { revivedKeys, hadUnexpectedShape } = publishDurableStoreEntries(durableRecords, 
         // TODO [W-10072584]: instead of implicitly using L1 we should take in
         // publish and publishMetadata funcs, so callers can decide where to
@@ -147,18 +153,18 @@ unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
         // if the data coming back from DS had an unexpected shape then just
         // return the L1 snapshot
         if (hadUnexpectedShape === true) {
-            return unavailableSnapshot;
+            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
         }
         if (keys(revivedKeys).length === 0) {
             // durable store doesn't have what we asked for so return L1 snapshot
-            return unavailableSnapshot;
+            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
         }
         // try building the snapshot from L1 now that we have revived the missingLinks
         const snapshot = buildL1Snapshot();
         // if snapshot is pending then some other in-flight refresh will broadcast
         // later
         if (snapshot.state === 'Pending') {
-            return snapshot;
+            return { snapshot, metrics: reviveMetrics };
         }
         if (snapshot.state === 'Unfulfilled') {
             // have to check if the new snapshot has any additional seenRecords
@@ -174,15 +180,15 @@ unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
             for (let i = 0, len = newKeys.length; i < len; i++) {
                 const newSnapshotSeenKey = newKeys[i];
                 if (alreadyRequestedOrRevivedSet[newSnapshotSeenKey] !== true) {
-                    return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot);
+                    return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
                 }
             }
         }
-        return snapshot;
+        return { snapshot, metrics: reviveMetrics };
     }, (error) => {
         durableStoreErrorHandler(error);
         // getEntries failed, return the L1 snapshot
-        return unavailableSnapshot;
+        return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
     });
 }
 
@@ -324,6 +330,19 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
     return Promise.resolve();
 }
 
+const DurableEnvironmentEventDiscriminator = 'durable';
+function isDurableEnvironmentEvent(event) {
+    return (event.type === 'environment' && event.environment === DurableEnvironmentEventDiscriminator);
+}
+function emitDurableEnvironmentAdapterEvent(eventData, observers) {
+    emitAdapterEvent({
+        type: 'environment',
+        timestamp: Date.now(),
+        environment: DurableEnvironmentEventDiscriminator,
+        data: eventData,
+    }, observers);
+}
+
 const AdapterContextSegment = 'ADAPTER-CONTEXT';
 const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
 function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, onContextLoaded) {
@@ -535,7 +554,9 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, () => 
         // reviveSnapshot will revive into L1, and since "records" is a reference
         // (and not a copy) to the L1 records we can use it for rebuild
-        environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, () => { })).then(onAsyncRebuild);
+        environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, () => { })).then((result) => {
+            onAsyncRebuild(result.snapshot);
+        });
         // synchronously return the base snapshot as Pending if not already
         return snapshot.state === 'Pending'
             ? snapshot
@@ -592,7 +613,18 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // if the adapter attempted to do an L1 lookup and it was unfulfilled
             // then we can attempt an L2 lookup
             if (isUnfulfilledSnapshot(snapshot)) {
-                return reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => storeLookup(snapshot.select, snapshot.refresh));
+                const start = Date.now();
+                emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
+                const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => storeLookup(snapshot.select, snapshot.refresh)).then((result) => {
+                    emitDurableEnvironmentAdapterEvent({
+                        type: 'l2-revive-end',
+                        duration: Date.now() - start,
+                        l2Trips: result.metrics.l2ReadCount,
+                        l2Duration: result.metrics.l2ReadDuration,
+                    }, adapterRequestContext.eventObservers);
+                    return result.snapshot;
+                });
+                return revivedSnapshot;
             }
             // otherwise just return what buildCachedSnapshot gave us
             return snapshot;
@@ -645,7 +677,9 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                     return snapshotFromMemoryIngest;
                 }
                 // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-                return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh));
+                return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh)).then((result) => {
+                    return result.snapshot;
+                });
             });
         };
         if (keys(keysToRevive).length === 0) {
@@ -711,4 +745,4 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     });
 }
 
-export { DefaultDurableSegment, DurableStoreOperationType, makeDurable, publishDurableStoreEntries };
+export { DefaultDurableSegment, DurableStoreOperationType, isDurableEnvironmentEvent, makeDurable, publishDurableStoreEntries };

package/dist/es/es2018/events.d.ts

@@ -0,0 +1,15 @@
+import type { EnvironmentAdapterEvent } from '@luvio/engine';
+import type { LuvioAdapterEventObserver } from '@luvio/engine';
+interface ReviveStartEvent {
+    type: 'l2-revive-start';
+}
+interface ReviveEndEvent {
+    type: 'l2-revive-end';
+    duration: number;
+    l2Trips: number;
+    l2Duration: number;
+}
+export declare type DurableEnvironmentAdapterEventData = ReviveStartEvent | ReviveEndEvent;
+export declare function isDurableEnvironmentEvent(event: EnvironmentAdapterEvent<unknown>): event is EnvironmentAdapterEvent<DurableEnvironmentAdapterEventData>;
+export declare function emitDurableEnvironmentAdapterEvent(eventData: DurableEnvironmentAdapterEventData, observers: LuvioAdapterEventObserver[] | undefined): void;
+export {};

package/dist/es/es2018/main.d.ts

@@ -2,3 +2,4 @@ export { DurableStore, DurableStoreEntries, DurableStoreEntry, DurableStoreChang
 export { DurableTTLOverride, DefaultDurableTTLOverride } from './DurableTTLStore';
 export { makeDurable, DurableEnvironment } from './makeDurable';
 export { publishDurableStoreEntries } from './makeDurable/revive';
+export { isDurableEnvironmentEvent } from './events';

package/dist/es/es2018/makeDurable/revive.d.ts

@@ -20,11 +20,19 @@ declare type ReviveResponse = {
  * @returns
  */
 export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
+interface ReviveMetrics {
+    l2ReadCount: number;
+    l2ReadDuration: number;
+}
+interface ReviveResult<D, V> {
+    snapshot: Snapshot<D, V>;
+    metrics: ReviveMetrics;
+}
 /**
  * This method returns a Promise to a snapshot that is revived from L2 cache.  If
  * L2 does not have the entries necessary to fulfill the snapshot then this method
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnAvailableSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>): Promise<Snapshot<D, V>>;
+export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnAvailableSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, reviveMetrics?: ReviveMetrics): Promise<ReviveResult<D, V>>;
 export {};

package/dist/umd/es2018/environments.js

@@ -130,19 +130,25 @@
      */
     function reviveSnapshot(baseEnvironment, durableStore, 
     // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
-    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
+    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics = { l2ReadCount: 0, l2ReadDuration: 0 }) {
         const { recordId, select, seenRecords, state } = unavailableSnapshot;
         // L2 can only revive Unfulfilled snapshots that have a selector since they have the
         // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
         if (state !== 'Unfulfilled' || select === undefined) {
-            return Promise.resolve(unavailableSnapshot);
+            return Promise.resolve({
+                snapshot: unavailableSnapshot,
+                metrics: reviveMetrics,
+            });
         }
         // in case L1 store changes/deallocs a record while we are doing the async read
         // we attempt to read all keys from L2 - so combine recordId with any seenRecords
         const keysToReviveSet = assign({ [recordId]: true }, seenRecords);
         const keysToRevive = keys(keysToReviveSet);
         const canonicalKeys = keysToRevive.map((x) => baseEnvironment.storeGetCanonicalKey(x));
+        const start = Date.now();
+        reviveMetrics.l2ReadCount++;
         return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
+            reviveMetrics.l2ReadDuration += Date.now() - start;
             const { revivedKeys, hadUnexpectedShape } = publishDurableStoreEntries(durableRecords, 
             // TODO [W-10072584]: instead of implicitly using L1 we should take in
             // publish and publishMetadata funcs, so callers can decide where to
@@ -151,18 +157,18 @@
             // if the data coming back from DS had an unexpected shape then just
             // return the L1 snapshot
             if (hadUnexpectedShape === true) {
-                return unavailableSnapshot;
+                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
             }
             if (keys(revivedKeys).length === 0) {
                 // durable store doesn't have what we asked for so return L1 snapshot
-                return unavailableSnapshot;
+                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
             }
             // try building the snapshot from L1 now that we have revived the missingLinks
             const snapshot = buildL1Snapshot();
             // if snapshot is pending then some other in-flight refresh will broadcast
             // later
             if (snapshot.state === 'Pending') {
-                return snapshot;
+                return { snapshot, metrics: reviveMetrics };
             }
             if (snapshot.state === 'Unfulfilled') {
                 // have to check if the new snapshot has any additional seenRecords
@@ -178,15 +184,15 @@
                 for (let i = 0, len = newKeys.length; i < len; i++) {
                     const newSnapshotSeenKey = newKeys[i];
                     if (alreadyRequestedOrRevivedSet[newSnapshotSeenKey] !== true) {
-                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot);
+                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
                     }
                 }
             }
-            return snapshot;
+            return { snapshot, metrics: reviveMetrics };
         }, (error) => {
             durableStoreErrorHandler(error);
             // getEntries failed, return the L1 snapshot
-            return unavailableSnapshot;
+            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
         });
     }
 
@@ -328,6 +334,19 @@
         return Promise.resolve();
     }
 
+    const DurableEnvironmentEventDiscriminator = 'durable';
+    function isDurableEnvironmentEvent(event) {
+        return (event.type === 'environment' && event.environment === DurableEnvironmentEventDiscriminator);
+    }
+    function emitDurableEnvironmentAdapterEvent(eventData, observers) {
+        engine.emitAdapterEvent({
+            type: 'environment',
+            timestamp: Date.now(),
+            environment: DurableEnvironmentEventDiscriminator,
+            data: eventData,
+        }, observers);
+    }
+
     const AdapterContextSegment = 'ADAPTER-CONTEXT';
     const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
     function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, onContextLoaded) {
@@ -539,7 +558,9 @@
             reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, () => 
             // reviveSnapshot will revive into L1, and since "records" is a reference
             // (and not a copy) to the L1 records we can use it for rebuild
-            environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, () => { })).then(onAsyncRebuild);
+            environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, () => { })).then((result) => {
+                onAsyncRebuild(result.snapshot);
+            });
             // synchronously return the base snapshot as Pending if not already
             return snapshot.state === 'Pending'
                 ? snapshot
@@ -596,7 +617,18 @@
                 // if the adapter attempted to do an L1 lookup and it was unfulfilled
                 // then we can attempt an L2 lookup
                 if (isUnfulfilledSnapshot(snapshot)) {
-                    return reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => storeLookup(snapshot.select, snapshot.refresh));
+                    const start = Date.now();
+                    emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
+                    const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => storeLookup(snapshot.select, snapshot.refresh)).then((result) => {
+                        emitDurableEnvironmentAdapterEvent({
+                            type: 'l2-revive-end',
+                            duration: Date.now() - start,
+                            l2Trips: result.metrics.l2ReadCount,
+                            l2Duration: result.metrics.l2ReadDuration,
+                        }, adapterRequestContext.eventObservers);
+                        return result.snapshot;
+                    });
+                    return revivedSnapshot;
                 }
                 // otherwise just return what buildCachedSnapshot gave us
                 return snapshot;
@@ -649,7 +681,9 @@
                         return snapshotFromMemoryIngest;
                     }
                     // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-                    return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh));
+                    return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh)).then((result) => {
+                        return result.snapshot;
+                    });
                 });
             };
             if (keys(keysToRevive).length === 0) {
@@ -716,6 +750,7 @@
     }
 
     exports.DefaultDurableSegment = DefaultDurableSegment;
+    exports.isDurableEnvironmentEvent = isDurableEnvironmentEvent;
     exports.makeDurable = makeDurable;
     exports.publishDurableStoreEntries = publishDurableStoreEntries;
 

package/dist/umd/es2018/events.d.ts

@@ -0,0 +1,15 @@
+import type { EnvironmentAdapterEvent } from '@luvio/engine';
+import type { LuvioAdapterEventObserver } from '@luvio/engine';
+interface ReviveStartEvent {
+    type: 'l2-revive-start';
+}
+interface ReviveEndEvent {
+    type: 'l2-revive-end';
+    duration: number;
+    l2Trips: number;
+    l2Duration: number;
+}
+export declare type DurableEnvironmentAdapterEventData = ReviveStartEvent | ReviveEndEvent;
+export declare function isDurableEnvironmentEvent(event: EnvironmentAdapterEvent<unknown>): event is EnvironmentAdapterEvent<DurableEnvironmentAdapterEventData>;
+export declare function emitDurableEnvironmentAdapterEvent(eventData: DurableEnvironmentAdapterEventData, observers: LuvioAdapterEventObserver[] | undefined): void;
+export {};

package/dist/umd/es2018/main.d.ts

@@ -2,3 +2,4 @@ export { DurableStore, DurableStoreEntries, DurableStoreEntry, DurableStoreChang
 export { DurableTTLOverride, DefaultDurableTTLOverride } from './DurableTTLStore';
 export { makeDurable, DurableEnvironment } from './makeDurable';
 export { publishDurableStoreEntries } from './makeDurable/revive';
+export { isDurableEnvironmentEvent } from './events';

package/dist/umd/es2018/makeDurable/revive.d.ts

@@ -20,11 +20,19 @@ declare type ReviveResponse = {
  * @returns
  */
 export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
+interface ReviveMetrics {
+    l2ReadCount: number;
+    l2ReadDuration: number;
+}
+interface ReviveResult<D, V> {
+    snapshot: Snapshot<D, V>;
+    metrics: ReviveMetrics;
+}
 /**
  * This method returns a Promise to a snapshot that is revived from L2 cache.  If
  * L2 does not have the entries necessary to fulfill the snapshot then this method
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnAvailableSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>): Promise<Snapshot<D, V>>;
+export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnAvailableSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, reviveMetrics?: ReviveMetrics): Promise<ReviveResult<D, V>>;
 export {};

package/dist/umd/es5/environments.js

@@ -167,21 +167,28 @@
      */
     function reviveSnapshot(baseEnvironment, durableStore, 
     // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
-    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
+    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics) {
         var _a;
+        if (reviveMetrics === void 0) { reviveMetrics = { l2ReadCount: 0, l2ReadDuration: 0 }; }
         var recordId = unavailableSnapshot.recordId, select = unavailableSnapshot.select, seenRecords = unavailableSnapshot.seenRecords, state = unavailableSnapshot.state;
         // L2 can only revive Unfulfilled snapshots that have a selector since they have the
         // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
         if (state !== 'Unfulfilled' || select === undefined) {
-            return Promise.resolve(unavailableSnapshot);
+            return Promise.resolve({
+                snapshot: unavailableSnapshot,
+                metrics: reviveMetrics,
+            });
         }
         // in case L1 store changes/deallocs a record while we are doing the async read
         // we attempt to read all keys from L2 - so combine recordId with any seenRecords
         var keysToReviveSet = assign((_a = {}, _a[recordId] = true, _a), seenRecords);
         var keysToRevive = keys(keysToReviveSet);
         var canonicalKeys = keysToRevive.map(function (x) { return baseEnvironment.storeGetCanonicalKey(x); });
+        var start = Date.now();
+        reviveMetrics.l2ReadCount++;
         return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then(function (durableRecords) {
             var _a;
+            reviveMetrics.l2ReadDuration += Date.now() - start;
             var _b = publishDurableStoreEntries(durableRecords, 
             // TODO [W-10072584]: instead of implicitly using L1 we should take in
             // publish and publishMetadata funcs, so callers can decide where to
@@ -190,18 +197,18 @@
             // if the data coming back from DS had an unexpected shape then just
             // return the L1 snapshot
             if (hadUnexpectedShape === true) {
-                return unavailableSnapshot;
+                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
             }
             if (keys(revivedKeys).length === 0) {
                 // durable store doesn't have what we asked for so return L1 snapshot
-                return unavailableSnapshot;
+                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
             }
             // try building the snapshot from L1 now that we have revived the missingLinks
             var snapshot = buildL1Snapshot();
             // if snapshot is pending then some other in-flight refresh will broadcast
             // later
             if (snapshot.state === 'Pending') {
-                return snapshot;
+                return { snapshot: snapshot, metrics: reviveMetrics };
             }
             if (snapshot.state === 'Unfulfilled') {
                 // have to check if the new snapshot has any additional seenRecords
@@ -217,15 +224,15 @@
                 for (var i = 0, len = newKeys.length; i < len; i++) {
                     var newSnapshotSeenKey = newKeys[i];
                     if (alreadyRequestedOrRevivedSet[newSnapshotSeenKey] !== true) {
-                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot);
+                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
                     }
                 }
             }
-            return snapshot;
+            return { snapshot: snapshot, metrics: reviveMetrics };
         }, function (error) {
             durableStoreErrorHandler(error);
             // getEntries failed, return the L1 snapshot
-            return unavailableSnapshot;
+            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
         });
     }
 
@@ -370,6 +377,19 @@
         return Promise.resolve();
     }
 
+    var DurableEnvironmentEventDiscriminator = 'durable';
+    function isDurableEnvironmentEvent(event) {
+        return (event.type === 'environment' && event.environment === DurableEnvironmentEventDiscriminator);
+    }
+    function emitDurableEnvironmentAdapterEvent(eventData, observers) {
+        engine.emitAdapterEvent({
+            type: 'environment',
+            timestamp: Date.now(),
+            environment: DurableEnvironmentEventDiscriminator,
+            data: eventData,
+        }, observers);
+    }
+
     var AdapterContextSegment = 'ADAPTER-CONTEXT';
     var ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
     function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, onContextLoaded) {
@@ -584,7 +604,9 @@
                 // reviveSnapshot will revive into L1, and since "records" is a reference
                 // (and not a copy) to the L1 records we can use it for rebuild
                 return environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, function () { });
-            }).then(onAsyncRebuild);
+            }).then(function (result) {
+                onAsyncRebuild(result.snapshot);
+            });
             // synchronously return the base snapshot as Pending if not already
             return snapshot.state === 'Pending'
                 ? snapshot
@@ -638,7 +660,18 @@
                 // if the adapter attempted to do an L1 lookup and it was unfulfilled
                 // then we can attempt an L2 lookup
                 if (isUnfulfilledSnapshot(snapshot)) {
-                    return reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () { return storeLookup(snapshot.select, snapshot.refresh); });
+                    var start_1 = Date.now();
+                    emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
+                    var revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () { return storeLookup(snapshot.select, snapshot.refresh); }).then(function (result) {
+                        emitDurableEnvironmentAdapterEvent({
+                            type: 'l2-revive-end',
+                            duration: Date.now() - start_1,
+                            l2Trips: result.metrics.l2ReadCount,
+                            l2Duration: result.metrics.l2ReadDuration,
+                        }, adapterRequestContext.eventObservers);
+                        return result.snapshot;
+                    });
+                    return revivedSnapshot;
                 }
                 // otherwise just return what buildCachedSnapshot gave us
                 return snapshot;
@@ -692,6 +725,8 @@
                     // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
                     return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () {
                         return environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh);
+                    }).then(function (result) {
+                        return result.snapshot;
                     });
                 });
             };
@@ -759,6 +794,7 @@
     }
 
     exports.DefaultDurableSegment = DefaultDurableSegment;
+    exports.isDurableEnvironmentEvent = isDurableEnvironmentEvent;
     exports.makeDurable = makeDurable;
     exports.publishDurableStoreEntries = publishDurableStoreEntries;
 

package/dist/umd/es5/events.d.ts

@@ -0,0 +1,15 @@
+import type { EnvironmentAdapterEvent } from '@luvio/engine';
+import type { LuvioAdapterEventObserver } from '@luvio/engine';
+interface ReviveStartEvent {
+    type: 'l2-revive-start';
+}
+interface ReviveEndEvent {
+    type: 'l2-revive-end';
+    duration: number;
+    l2Trips: number;
+    l2Duration: number;
+}
+export declare type DurableEnvironmentAdapterEventData = ReviveStartEvent | ReviveEndEvent;
+export declare function isDurableEnvironmentEvent(event: EnvironmentAdapterEvent<unknown>): event is EnvironmentAdapterEvent<DurableEnvironmentAdapterEventData>;
+export declare function emitDurableEnvironmentAdapterEvent(eventData: DurableEnvironmentAdapterEventData, observers: LuvioAdapterEventObserver[] | undefined): void;
+export {};

package/dist/umd/es5/main.d.ts

@@ -2,3 +2,4 @@ export { DurableStore, DurableStoreEntries, DurableStoreEntry, DurableStoreChang
 export { DurableTTLOverride, DefaultDurableTTLOverride } from './DurableTTLStore';
 export { makeDurable, DurableEnvironment } from './makeDurable';
 export { publishDurableStoreEntries } from './makeDurable/revive';
+export { isDurableEnvironmentEvent } from './events';

package/dist/umd/es5/makeDurable/revive.d.ts

@@ -20,11 +20,19 @@ declare type ReviveResponse = {
  * @returns
  */
 export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
+interface ReviveMetrics {
+    l2ReadCount: number;
+    l2ReadDuration: number;
+}
+interface ReviveResult<D, V> {
+    snapshot: Snapshot<D, V>;
+    metrics: ReviveMetrics;
+}
 /**
  * This method returns a Promise to a snapshot that is revived from L2 cache.  If
  * L2 does not have the entries necessary to fulfill the snapshot then this method
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnAvailableSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>): Promise<Snapshot<D, V>>;
+export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnAvailableSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, reviveMetrics?: ReviveMetrics): Promise<ReviveResult<D, V>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.96.0",
+    "version": "0.98.0",
     "description": "Luvio Environments",
     "main": "dist/umd/es2018/environments.js",
     "module": "dist/es/es2018/environments.js",
@@ -27,7 +27,7 @@
         "dist/"
     ],
     "dependencies": {
-        "@luvio/engine": "0.96.0"
+        "@luvio/engine": "0.98.0"
     },
     "bundlesize": [
         {