build: refresh js files

lib/analyze.js

@@ -423,6 +423,12 @@ async function runQueries(sarifFolder, memoryFlag, addSnippetsFlag, threadsFlag,
         queryFlags.push("--extension-packs=codeql-action/pr-diff-range");
         incrementalMode.push("diff-informed");
     }
+    statusReport.analysis_is_overlay =
+        config.augmentationProperties.overlayDatabaseMode ===
+            overlay_database_utils_1.OverlayDatabaseMode.Overlay;
+    statusReport.analysis_builds_overlay_base_database =
+        config.augmentationProperties.overlayDatabaseMode ===
+            overlay_database_utils_1.OverlayDatabaseMode.OverlayBase;
     if (config.augmentationProperties.overlayDatabaseMode ===
         overlay_database_utils_1.OverlayDatabaseMode.Overlay) {
         incrementalMode.push("overlay");

lib/analyze.test.js

@@ -116,7 +116,9 @@ const util = __importStar(require("./util"));
             });
             const statusReport = await (0, analyze_1.runQueries)(tmpDir, memoryFlag, addSnippetsFlag, threadsFlag, "brutal", undefined, undefined, config, (0, logging_1.getRunnerLogger)(true), (0, testing_utils_1.createFeatures)([feature_flags_1.Feature.QaTelemetryEnabled]));
             t.deepEqual(Object.keys(statusReport).sort(), [
+                "analysis_builds_overlay_base_database",
                 "analysis_is_diff_informed",
+                "analysis_is_overlay",
                 `analyze_builtin_queries_${language}_duration_ms`,
                 "event_reports",
                 `interpret_results_${language}_duration_ms`,

lib/init-action.js

@@ -57,7 +57,7 @@ const status_report_1 = require("./status-report");
 const tools_features_1 = require("./tools-features");
 const util_1 = require("./util");
 const workflow_1 = require("./workflow");
-async function sendCompletedStatusReport(startedAt, config, configFile, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, logger, error) {
+async function sendCompletedStatusReport(startedAt, config, configFile, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, overlayBaseDatabaseStats, logger, error) {
     const statusReportBase = await (0, status_report_1.createStatusReportBase)(status_report_1.ActionName.Init, (0, status_report_1.getActionsStatus)(error), startedAt, config, await (0, util_1.checkDiskUsage)(logger), logger, error?.message, error?.stack);
     if (statusReportBase === undefined) {
         return;
@@ -126,6 +126,8 @@ async function sendCompletedStatusReport(startedAt, config, configFile, toolsDow
             trap_cache_languages: Object.keys(config.trapCaches).join(","),
             trap_cache_download_size_bytes: Math.round(await (0, caching_utils_1.getTotalCacheSize)(Object.values(config.trapCaches), logger)),
             trap_cache_download_duration_ms: Math.round(config.trapCacheDownloadTime),
+            overlay_base_database_download_size_bytes: overlayBaseDatabaseStats?.databaseSizeBytes,
+            overlay_base_database_download_duration_ms: overlayBaseDatabaseStats?.databaseDownloadDurationMs,
             query_filters: JSON.stringify(config.originalUserInput["query-filters"] ?? []),
             registries: JSON.stringify(configUtils.parseRegistriesWithoutCredentials((0, actions_util_1.getOptionalInput)("registries")) ?? []),
         };
@@ -232,6 +234,7 @@ async function run() {
         }
         return;
     }
+    let overlayBaseDatabaseStats;
     try {
         if (config.augmentationProperties.overlayDatabaseMode ===
             overlay_database_utils_1.OverlayDatabaseMode.Overlay &&
@@ -247,8 +250,8 @@ async function run() {
             // necessary preparations. So, in that mode, we would assume that
             // everything is in order and let the analysis fail if that turns out not
             // to be the case.
-            const overlayDatabaseDownloaded = await (0, overlay_database_utils_1.downloadOverlayBaseDatabaseFromCache)(codeql, config, logger);
+            overlayBaseDatabaseStats = await (0, overlay_database_utils_1.downloadOverlayBaseDatabaseFromCache)(codeql, config, logger);
-            if (!overlayDatabaseDownloaded) {
+            if (!overlayBaseDatabaseStats) {
                 config.augmentationProperties.overlayDatabaseMode =
                     overlay_database_utils_1.OverlayDatabaseMode.None;
                 logger.info("No overlay-base database found in cache, " +
@@ -443,13 +446,13 @@ async function run() {
         const error = (0, util_1.wrapError)(unwrappedError);
         core.setFailed(error.message);
         await sendCompletedStatusReport(startedAt, config, undefined, // We only report config info on success.
-        toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, logger, error);
+        toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, overlayBaseDatabaseStats, logger, error);
         return;
     }
     finally {
         (0, diagnostics_1.logUnwrittenDiagnostics)();
     }
-    await sendCompletedStatusReport(startedAt, config, configFile, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, logger);
+    await sendCompletedStatusReport(startedAt, config, configFile, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, overlayBaseDatabaseStats, logger);
 }
 function getTrapCachingEnabled() {
     // If the workflow specified something always respect that

lib/overlay-database-utils.js

@@ -213,51 +213,67 @@ async function uploadOverlayBaseDatabaseToCache(codeql, config, logger) {
  * @param codeql The CodeQL instance
  * @param config The configuration object
  * @param logger The logger instance
- * @returns A promise that resolves to true if the download was performed and
+ * @returns A promise that resolves to download statistics if an overlay-base
- * successfully completed, or false otherwise
+ * database was successfully downloaded, or undefined if the download was
+ * either not performed or failed.
  */
 async function downloadOverlayBaseDatabaseFromCache(codeql, config, logger) {
     const overlayDatabaseMode = config.augmentationProperties.overlayDatabaseMode;
     if (overlayDatabaseMode !== OverlayDatabaseMode.Overlay) {
         logger.debug(`Overlay database mode is ${overlayDatabaseMode}. ` +
             "Skip downloading overlay-base database from cache.");
-        return false;
+        return undefined;
     }
     if (!config.augmentationProperties.useOverlayDatabaseCaching) {
         logger.debug("Overlay database caching is disabled. " +
             "Skip downloading overlay-base database from cache.");
-        return false;
+        return undefined;
     }
     if ((0, util_1.isInTestMode)()) {
         logger.debug("In test mode. Skip downloading overlay-base database from cache.");
-        return false;
+        return undefined;
     }
     const dbLocation = config.dbLocation;
     const codeQlVersion = (await codeql.getVersion()).version;
     const restoreKey = getCacheRestoreKey(config, codeQlVersion);
     logger.info(`Looking in Actions cache for overlay-base database with restore key ${restoreKey}`);
+    let databaseDownloadDurationMs = 0;
     try {
+        const databaseDownloadStart = performance.now();
         const foundKey = await (0, util_1.withTimeout)(MAX_CACHE_OPERATION_MS, actionsCache.restoreCache([dbLocation], restoreKey), () => {
             logger.info("Timed out downloading overlay-base database from cache");
         });
+        databaseDownloadDurationMs = Math.round(performance.now() - databaseDownloadStart);
         if (foundKey === undefined) {
             logger.info("No overlay-base database found in Actions cache");
-            return false;
+            return undefined;
         }
         logger.info(`Downloaded overlay-base database in cache with key ${foundKey}`);
     }
     catch (error) {
         logger.warning("Failed to download overlay-base database from cache: " +
             `${error instanceof Error ? error.message : String(error)}`);
-        return false;
+        return undefined;
     }
     const databaseIsValid = checkOverlayBaseDatabase(config, logger, "Downloaded overlay-base database is invalid");
     if (!databaseIsValid) {
         logger.warning("Downloaded overlay-base database failed validation");
-        return false;
+        return undefined;
+    }
+    const databaseSizeBytes = await (0, util_1.tryGetFolderBytes)(dbLocation, logger);
+    if (databaseSizeBytes === undefined) {
+        logger.info("Filesystem error while accessing downloaded overlay-base database");
+        // The problem that warrants reporting download failure is not that we are
+        // unable to determine the size of the database. Rather, it is that we
+        // encountered a filesystem error while accessing the database, which
+        // indicates that an overlay analysis will likely fail.
+        return undefined;
     }
     logger.info(`Successfully downloaded overlay-base database to ${dbLocation}`);
-    return true;
+    return {
+        databaseSizeBytes: Math.round(databaseSizeBytes),
+        databaseDownloadDurationMs,
+    };
 }
 async function generateCacheKey(config, codeQlVersion, checkoutPath) {
     const sha = await (0, git_utils_1.getCommitOid)(checkoutPath);

lib/overlay-database-utils.test.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const actionsCache = __importStar(require("@actions/cache"));
 const ava_1 = __importDefault(require("ava"));
 const sinon = __importStar(require("sinon"));
 const actionsUtil = __importStar(require("./actions-util"));
@@ -45,6 +46,7 @@ const gitUtils = __importStar(require("./git-utils"));
 const logging_1 = require("./logging");
 const overlay_database_utils_1 = require("./overlay-database-utils");
 const testing_utils_1 = require("./testing-utils");
+const utils = __importStar(require("./util"));
 const util_1 = require("./util");
 (0, testing_utils_1.setupTests)(ava_1.default);
 (0, ava_1.default)("writeOverlayChangesFile generates correct changes file", async (t) => {
@@ -91,4 +93,93 @@ const util_1 = require("./util");
         t.deepEqual(parsedContent.changes.sort(), ["added.js", "deleted.js", "modified.js"], "Should identify added, deleted, and modified files");
     });
 });
+const defaultDownloadTestCase = {
+    overlayDatabaseMode: overlay_database_utils_1.OverlayDatabaseMode.Overlay,
+    useOverlayDatabaseCaching: true,
+    isInTestMode: false,
+    restoreCacheResult: "cache-key",
+    hasBaseDatabaseOidsFile: true,
+    tryGetFolderBytesSucceeds: true,
+    codeQLVersion: "2.20.5",
+};
+const testDownloadOverlayBaseDatabaseFromCache = ava_1.default.macro({
+    exec: async (t, _title, partialTestCase, expectDownloadSuccess) => {
+        await (0, util_1.withTmpDir)(async (tmpDir) => {
+            const dbLocation = path.join(tmpDir, "db");
+            await fs.promises.mkdir(dbLocation, { recursive: true });
+            const logger = (0, logging_1.getRunnerLogger)(true);
+            const config = (0, testing_utils_1.createTestConfig)({ dbLocation });
+            const testCase = { ...defaultDownloadTestCase, ...partialTestCase };
+            config.augmentationProperties.overlayDatabaseMode =
+                testCase.overlayDatabaseMode;
+            config.augmentationProperties.useOverlayDatabaseCaching =
+                testCase.useOverlayDatabaseCaching;
+            if (testCase.hasBaseDatabaseOidsFile) {
+                const baseDatabaseOidsFile = path.join(dbLocation, "base-database-oids.json");
+                await fs.promises.writeFile(baseDatabaseOidsFile, JSON.stringify({}));
+            }
+            const stubs = [];
+            const isInTestModeStub = sinon
+                .stub(utils, "isInTestMode")
+                .returns(testCase.isInTestMode);
+            stubs.push(isInTestModeStub);
+            if (testCase.restoreCacheResult instanceof Error) {
+                const restoreCacheStub = sinon
+                    .stub(actionsCache, "restoreCache")
+                    .rejects(testCase.restoreCacheResult);
+                stubs.push(restoreCacheStub);
+            }
+            else {
+                const restoreCacheStub = sinon
+                    .stub(actionsCache, "restoreCache")
+                    .resolves(testCase.restoreCacheResult);
+                stubs.push(restoreCacheStub);
+            }
+            const tryGetFolderBytesStub = sinon
+                .stub(utils, "tryGetFolderBytes")
+                .resolves(testCase.tryGetFolderBytesSucceeds ? 1024 * 1024 : undefined);
+            stubs.push(tryGetFolderBytesStub);
+            try {
+                const result = await (0, overlay_database_utils_1.downloadOverlayBaseDatabaseFromCache)((0, testing_utils_1.mockCodeQLVersion)(testCase.codeQLVersion), config, logger);
+                if (expectDownloadSuccess) {
+                    t.truthy(result);
+                }
+                else {
+                    t.is(result, undefined);
+                }
+            }
+            finally {
+                for (const stub of stubs) {
+                    stub.restore();
+                }
+            }
+        });
+    },
+    title: (_, title) => `downloadOverlayBaseDatabaseFromCache: ${title}`,
+});
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns stats when successful", {}, true);
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns undefined when mode is OverlayDatabaseMode.OverlayBase", {
+    overlayDatabaseMode: overlay_database_utils_1.OverlayDatabaseMode.OverlayBase,
+}, false);
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns undefined when mode is OverlayDatabaseMode.None", {
+    overlayDatabaseMode: overlay_database_utils_1.OverlayDatabaseMode.None,
+}, false);
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns undefined when caching is disabled", {
+    useOverlayDatabaseCaching: false,
+}, false);
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns undefined in test mode", {
+    isInTestMode: true,
+}, false);
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns undefined when cache miss", {
+    restoreCacheResult: undefined,
+}, false);
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns undefined when download fails", {
+    restoreCacheResult: new Error("Download failed"),
+}, false);
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns undefined when downloaded database is invalid", {
+    hasBaseDatabaseOidsFile: false,
+}, false);
+(0, ava_1.default)(testDownloadOverlayBaseDatabaseFromCache, "returns undefined when filesystem error occurs", {
+    tryGetFolderBytesSucceeds: false,
+}, false);
 //# sourceMappingURL=overlay-database-utils.test.js.map