fix(crash): crash monitoring dir not being cleaned up

During development the underlying implementation was changed to get
the OS uptime. The initial implementation returned uptime in minutes,
but the new one returned it in seconds and this was not accounted for.

As a result the crash monitoring folder was not being cleaned up when expected
on computer restart

Signed-off-by: nkomonen-amazon <[email protected]>

Author: nkomonen-amazon

packages/core/src/shared/crashMonitoring.ts

@@ -492,7 +492,11 @@ export class FileSystemState {
         return p
     }
     public async clearState(): Promise<void> {
-        await withFailCtx('clearState', async () => fs.delete(this.stateDirPath, { force: true }))
+        this.deps.devLogger?.debug('crashMonitoring: CLEAR_STATE: Started')
+        await withFailCtx('clearState', async () => {
+            await fs.delete(this.stateDirPath, { force: true, recursive: true })
+            this.deps.devLogger?.debug('crashMonitoring: CLEAR_STATE: Succeeded')
+        })
     }
     public async getAllExts(): Promise<ExtInstanceHeartbeat[]> {
         const res = await withFailCtx('getAllExts', async () => {

packages/core/src/shared/utilities/osUtils.ts

@@ -15,20 +15,21 @@ import * as os from 'os'
  * Use this function to perform one-time initialization tasks that should only happen
  * once per OS session, regardless of how many extension instances are running.
  */
-export async function isNewOsSession(now = () => globals.clock.Date.now(), uptime = () => os.uptime()) {
+export async function isNewOsSession(now = () => globals.clock.Date.now(), uptimeMillis = () => os.uptime() * 1000) {
     // Windows does not have an ephemeral /tmp/ folder that deletes on shutdown, while unix-like os's do.
     // So in Windows we calculate the start time and see if it changed from the previous known start time.
     const lastStartTime = globals.globalState.tryGet('lastOsStartTime', Number)
-    // uptime() returns seconds, convert to ms
-    const currentOsStartTime = now() - uptime() * 1000 * 60
+
+    const uptime = uptimeMillis()
+    const currentOsStartTime = now() - uptime
 
     if (lastStartTime === undefined) {
         await globals.globalState.update('lastOsStartTime', currentOsStartTime)
         return true
     }
 
     // If the current start time is later than the last, it means we are in a new session since they should be the same value.
-    // But to account for small differences in how the current time is calculate, we add in a 5 second buffer.
+    // But to account for minor millisecond differnces, we add in a 5 second buffer.
     if (currentOsStartTime - 1000 * 5 > lastStartTime) {
         await globals.globalState.update('lastOsStartTime', currentOsStartTime)
         return true

packages/core/src/test/shared/utilities/osUtils.test.ts

@@ -22,32 +22,32 @@ describe('isNewOsSession', () => {
     })
 
     it('unix-like: returns true when expected', async () => {
-        const uptimeStub = sandbox.stub()
+        const uptimeMillisStub = sandbox.stub()
         const now = sandbox.stub()
-        // We started our computer at 2 minutes since epoch (time - pc uptime)
-        // and the comptuer has been on for 1 minute. So the OS started 1 minute since epoch.
-        now.returns(60_000 + 60_000)
-        uptimeStub.returns(1)
+        // We started our computer at 1 minutes since epoch and the comptuer uptime has been 1 minute.
+        // So the OS started at the epoch  (time - uptime).
+        now.returns(0) // the epoch time
+        uptimeMillisStub.returns(0) // this session has just started
 
         // On a brand new session the first caller will get true
-        assert.strictEqual(await isNewOsSession(now, uptimeStub), true)
+        assert.strictEqual(await isNewOsSession(now, uptimeMillisStub), true)
         // Subsequent callers will get false
-        assert.strictEqual(await isNewOsSession(now, uptimeStub), false)
-
-        // Start a computer session 10 minutes from epoch
-        uptimeStub.returns(0)
-        now.returns(60_000 * 10)
-        assert.strictEqual(await isNewOsSession(now, uptimeStub), true)
-        // Anything that is within a 5 second threshold of the last session time, is considered the same session
-        now.returns(60_000 * 10 + 5000)
-        assert.strictEqual(await isNewOsSession(now, uptimeStub), false)
-        now.returns(60_000 * 10 + 5000 + 1)
-        assert.strictEqual(await isNewOsSession(now, uptimeStub), true)
-
-        // A non-zero uptime
-        uptimeStub.returns(5) // The computer has been running for 5 minutes already, so the start time is relative to this.
-        now.returns(60_000 * 10 + 5000 + 60_000 * 10) // 5 minutes since last session
-        // Nothing changes since the diff between uptime and the last start has not changed
-        assert.strictEqual(await isNewOsSession(now, uptimeStub), true)
+        assert.strictEqual(await isNewOsSession(now, uptimeMillisStub), false)
+
+        // 10 minutes later, same session
+        now.returns(1000 * 60 * 10)
+        uptimeMillisStub.returns(1000 * 60 * 10) // This scales proportionately with the current time
+        // This is still the same session, so we get false
+        assert.strictEqual(await isNewOsSession(now, uptimeMillisStub), false)
+
+        // Test the lowerbound of what is considered a new session
+        // Pretend we started a new computer session 5 seconds after the initial session
+        uptimeMillisStub.returns(0)
+        now.returns(5000)
+        // Anything that is within a 5 second threshold of the last session time, is considered the SAME session
+        assert.strictEqual(await isNewOsSession(now, uptimeMillisStub), false)
+        // This is 1 millisecond after the threshold, it is considered a NEW session
+        now.returns(5000 + 1)
+        assert.strictEqual(await isNewOsSession(now, uptimeMillisStub), true)
     })
 })