@sasjs/cli 6.6.0 → 6.8.0

package/build/commands/logcheck/spec/renderLogCheck.spec.js

@@ -0,0 +1,426 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var renderLogCheck_1 = require("../renderLogCheck");
+var types_1 = require("../types");
+var config = types_1.defaultLogCheckConfig;
+var issue = function (overrides) {
+    if (overrides === void 0) { overrides = {}; }
+    return (__assign({ line: 11, endLine: 11, column: 4, endColumn: 20, severity: 'error', message: 'Syntax error, expecting one of the following' }, overrides));
+};
+var log = function (overrides) {
+    if (overrides === void 0) { overrides = {}; }
+    return (__assign({ filePath: '/project/sasjsresults/run.log', displayPath: 'sasjsresults/run.log', issues: [], suppressed: [], counts: { errors: 0, warnings: 0, notes: 0 } }, overrides));
+};
+var summary = function (overrides) {
+    if (overrides === void 0) { overrides = {}; }
+    return (__assign({ logs: [], skipped: [], missing: [], unreadable: [], usedDefaultInput: false, searched: ['sasjsresults'], totals: {
+            errors: 0,
+            warnings: 0,
+            notes: 0,
+            suppressed: 0,
+            logs: 0,
+            skipped: 0
+        } }, overrides));
+};
+var setupLogger = function () {
+    var logger = {
+        log: jest.fn(),
+        table: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        success: jest.fn()
+    };
+    process.logger = logger;
+    return {
+        logger: logger,
+        output: function () { return logger.log.mock.calls.map(function (call) { return call[0]; }).join('\n'); }
+    };
+};
+describe('renderHuman', function () {
+    afterEach(function () {
+        process.logger = undefined;
+    });
+    it('prints a file table, the issues and the verdict', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            logs: [
+                log({
+                    issues: [issue()],
+                    counts: { errors: 1, warnings: 0, notes: 0 }
+                })
+            ],
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 0
+            },
+            failure: '1 error'
+        }), config);
+        var printed = output();
+        expect(printed).toContain('SASjs logcheck');
+        expect(printed).toContain('sasjsresults/run.log');
+        expect(printed).toContain('FAIL');
+        expect(printed).toContain('12:5');
+        expect(printed).toContain('Syntax error, expecting one of the following');
+        expect(printed).toContain('1 error in 1 log');
+        expect(printed).toContain('Logcheck failed: 1 error');
+    });
+    it('says so when the policy is not to fail', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            logs: [
+                log({
+                    issues: [issue()],
+                    counts: { errors: 1, warnings: 0, notes: 0 }
+                })
+            ],
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 0
+            }
+        }), __assign(__assign({}, config), { failOn: 'never' }));
+        expect(output()).toContain('Logcheck passed (fail-on: never)');
+    });
+    it('reports the suppressed issues as a count, with the codes', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            logs: [
+                log({
+                    issues: [issue()],
+                    suppressed: [issue({ code: '49-169' })],
+                    counts: { errors: 1, warnings: 0, notes: 0 }
+                })
+            ],
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 1,
+                logs: 1,
+                skipped: 0
+            }
+        }), __assign(__assign({}, config), { ignoreCodes: ['49-169'] }));
+        expect(output()).toContain('1 issue suppressed by message code (49-169)');
+    });
+    it('names a missing path, and hints when it was the default', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            missing: ['sasjsresults'],
+            usedDefaultInput: true,
+            failure: '1 path not found'
+        }), config);
+        var printed = output();
+        expect(printed).toContain('Path not found: sasjsresults');
+        expect(printed).toContain('nothing has run yet, or pass a path');
+        expect(printed).not.toContain('No logs found at the path searched.');
+    });
+    it('reports a folder it could not read, and why', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            unreadable: [
+                {
+                    displayPath: 'sasjsresults/locked',
+                    reason: 'could not be listed (EACCES)'
+                }
+            ],
+            failure: '1 folder could not be read'
+        }), config);
+        var printed = output();
+        expect(printed).toContain('Could not read: sasjsresults/locked');
+        expect(printed).toContain('could not be listed (EACCES)');
+        expect(printed).toContain('Logcheck failed: 1 folder could not be read');
+    });
+    it('says when a folder holds nothing to check', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary(), config);
+        expect(output()).toContain('No logs found at the path searched.');
+    });
+    it('counts the skipped files, and lists them only when asked', function () {
+        var output = setupLogger().output;
+        var withSkips = summary({
+            logs: [log({ counts: { errors: 0, warnings: 0, notes: 0 } })],
+            skipped: [
+                { displayPath: 'sasjsresults/build.log', reason: 'not a SAS log' }
+            ],
+            totals: {
+                errors: 0,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 1
+            }
+        });
+        (0, renderLogCheck_1.renderHuman)(withSkips, config);
+        expect(output()).toContain('1 file skipped');
+        expect(output()).not.toContain('SKIPPED FILE');
+        var verbose = setupLogger();
+        (0, renderLogCheck_1.renderHuman)(withSkips, config, true);
+        expect(verbose.output()).toContain('SKIPPED FILE');
+        expect(verbose.output()).toContain('sasjsresults/build.log');
+    });
+});
+describe('fileFails', function () {
+    it('fails a log carrying an error under the default policy', function () {
+        expect((0, renderLogCheck_1.fileFails)({ errors: 1, warnings: 0, notes: 0 }, config)).toBe(true);
+        expect((0, renderLogCheck_1.fileFails)({ errors: 0, warnings: 4, notes: 4 }, config)).toBe(false);
+    });
+    it('follows the policy for warnings and notes', function () {
+        var warning = { errors: 0, warnings: 1, notes: 0 };
+        var note = { errors: 0, warnings: 0, notes: 1 };
+        expect((0, renderLogCheck_1.fileFails)(warning, __assign(__assign({}, config), { failOn: 'warning' }))).toBe(true);
+        expect((0, renderLogCheck_1.fileFails)(warning, __assign(__assign({}, config), { failOn: 'note' }))).toBe(true);
+        expect((0, renderLogCheck_1.fileFails)(note, __assign(__assign({}, config), { failOn: 'warning' }))).toBe(false);
+        expect((0, renderLogCheck_1.fileFails)(note, __assign(__assign({}, config), { failOn: 'note' }))).toBe(true);
+    });
+    it('fails nothing under the never policy', function () {
+        expect((0, renderLogCheck_1.fileFails)({ errors: 9, warnings: 9, notes: 9 }, __assign(__assign({}, config), { failOn: 'never' }))).toBe(false);
+    });
+    it('does not apply the run-wide warnings budget to one log', function () {
+        expect((0, renderLogCheck_1.fileFails)({ errors: 0, warnings: 3, notes: 0 }, __assign(__assign({}, config), { maxWarnings: 1 }))).toBe(false);
+    });
+});
+describe('columns', function () {
+    it('pads each column to the widest cell and underlines the head', function () {
+        var lines = (0, renderLogCheck_1.columns)([
+            ['a.log', '3'],
+            ['much-longer-name.log', '12']
+        ], ['FILE', 'ERRORS']);
+        expect(lines).toEqual([
+            'FILE                  ERRORS',
+            '--------------------  ------',
+            'a.log                 3',
+            'much-longer-name.log  12'
+        ]);
+    });
+    it('measures colour codes as no width at all', function () {
+        var coloured = '\u001b[31mred\u001b[39m';
+        var lines = (0, renderLogCheck_1.columns)([[coloured]], ['HEADER']);
+        expect(lines[1]).toEqual('------');
+    });
+    it('indents every line it returns', function () {
+        var lines = (0, renderLogCheck_1.columns)([['a']], ['A'], '  ', '    ');
+        expect(lines.every(function (line) { return line.startsWith('    '); })).toBe(true);
+    });
+});
+describe('truncate', function () {
+    it('leaves a short message alone', function () {
+        expect((0, renderLogCheck_1.truncate)('Syntax error')).toEqual('Syntax error');
+    });
+    it('collapses the whitespace SAS wrapped', function () {
+        expect((0, renderLogCheck_1.truncate)('a message\n      wrapped by SAS')).toEqual('a message wrapped by SAS');
+    });
+    it('cuts a long message on a word boundary', function () {
+        var message = 'word '.repeat(40).trim();
+        var cut = (0, renderLogCheck_1.truncate)(message);
+        expect(cut.length).toBeLessThanOrEqual(110);
+        expect(cut.endsWith('...')).toBe(true);
+        expect(cut).not.toContain('  ');
+        expect(message.startsWith(cut.replace('...', '').trim())).toBe(true);
+    });
+});
+describe('severityLabel', function () {
+    it('states the severity in words', function () {
+        expect((0, renderLogCheck_1.severityLabel)('error')).toEqual('error');
+        expect((0, renderLogCheck_1.severityLabel)('warning')).toEqual('warning');
+        expect((0, renderLogCheck_1.severityLabel)('note')).toEqual('note');
+    });
+});
+describe('lineLabel', function () {
+    it('is one-based, and names the range a message was wrapped over', function () {
+        expect((0, renderLogCheck_1.lineLabel)(issue())).toEqual('12:5');
+        expect((0, renderLogCheck_1.lineLabel)(issue({ endLine: 14 }))).toEqual('12-15:5');
+    });
+});
+describe('summarise', function () {
+    it('states what was found and over how many logs', function () {
+        expect((0, renderLogCheck_1.summarise)(summary({
+            totals: {
+                errors: 2,
+                warnings: 1,
+                notes: 0,
+                suppressed: 0,
+                logs: 2,
+                skipped: 0
+            }
+        }), 2)).toEqual('2 errors, 1 warning in 2 logs');
+    });
+    it('says so when there is nothing to report', function () {
+        expect((0, renderLogCheck_1.summarise)(summary({
+            totals: {
+                errors: 0,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 0
+            }
+        }), 1)).toEqual('No issues in 1 log');
+    });
+    it('names the files it read out of the files it saw', function () {
+        expect((0, renderLogCheck_1.summarise)(summary({
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 2
+            }
+        }), 1)).toEqual('1 error in 1 of 3 files');
+    });
+});
+describe('toJson', function () {
+    it('states line and column from one', function () {
+        var json = (0, renderLogCheck_1.toJson)(summary({
+            logs: [
+                log({
+                    issues: [issue({ code: '22-322' })],
+                    counts: { errors: 1, warnings: 0, notes: 0 }
+                })
+            ]
+        }), config);
+        expect(json.logs[0].issues[0]).toEqual({
+            line: 12,
+            endLine: 12,
+            column: 5,
+            endColumn: 21,
+            severity: 'error',
+            code: '22-322',
+            message: 'Syntax error, expecting one of the following'
+        });
+    });
+    it('leaves out a code an issue does not carry', function () {
+        var json = (0, renderLogCheck_1.toJson)(summary({ logs: [log({ issues: [issue()] })] }), config);
+        expect(json.logs[0].issues[0]).not.toHaveProperty('code');
+    });
+    it('lists a folder it could not read', function () {
+        var json = (0, renderLogCheck_1.toJson)(summary({
+            unreadable: [
+                { displayPath: 'logs/locked', reason: 'could not be listed' }
+            ]
+        }), config);
+        expect(json.unreadable).toEqual([
+            { folder: 'logs/locked', reason: 'could not be listed' }
+        ]);
+    });
+    it('carries the counts, the policy and the verdict', function () {
+        var json = (0, renderLogCheck_1.toJson)(summary({
+            logs: [
+                log({
+                    issues: [issue()],
+                    counts: { errors: 1, warnings: 0, notes: 0 },
+                    skippedReason: undefined
+                })
+            ],
+            skipped: [{ displayPath: 'build.log', reason: 'not a SAS log' }],
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 1
+            },
+            failure: '1 error'
+        }), __assign(__assign({}, config), { maxWarnings: 2 }));
+        expect(json.summary).toEqual({
+            logs: 1,
+            skipped: 1,
+            errors: 1,
+            warnings: 0,
+            notes: 0,
+            suppressed: 0,
+            failed: true,
+            failure: '1 error'
+        });
+        expect(json.config.maxWarnings).toEqual(2);
+        expect(json.skipped).toEqual([
+            { file: 'build.log', reason: 'not a SAS log' }
+        ]);
+    });
+});
+describe('toAnnotations', function () {
+    it('writes one workflow command per issue, with one-based positions', function () {
+        var annotations = (0, renderLogCheck_1.toAnnotations)(summary({
+            logs: [
+                log({
+                    issues: [
+                        issue({ code: '22-322' }),
+                        issue({ severity: 'warning', message: 'Symbol not resolved' }),
+                        issue({ severity: 'note', message: 'Division by zero' })
+                    ]
+                })
+            ]
+        }));
+        expect(annotations).toEqual([
+            '::error file=sasjsresults/run.log,line=12,col=5,endLine=12,endColumn=21,title=SAS ERROR 22-322::Syntax error, expecting one of the following',
+            '::warning file=sasjsresults/run.log,line=12,col=5,endLine=12,endColumn=21,title=SAS WARNING::Symbol not resolved',
+            '::notice file=sasjsresults/run.log,line=12,col=5,endLine=12,endColumn=21,title=SAS NOTE::Division by zero'
+        ]);
+    });
+    it('escapes what a workflow command reads as syntax', function () {
+        var annotations = (0, renderLogCheck_1.toAnnotations)(summary({
+            logs: [
+                log({
+                    displayPath: 'logs/with,comma.log',
+                    issues: [issue({ message: '100% wrong\nsecond line' })]
+                })
+            ]
+        }));
+        expect(annotations[0]).toContain('file=logs/with%2Ccomma.log');
+        expect(annotations[0]).toContain('::100%25 wrong%0Asecond line');
+    });
+});
+describe('renderLogCheck', function () {
+    afterEach(function () {
+        jest.restoreAllMocks();
+        process.logger = undefined;
+    });
+    it('writes JSON to stdout, and nothing through the logger', function () {
+        var logger = setupLogger().logger;
+        var write = jest
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(function () { return true; });
+        (0, renderLogCheck_1.renderLogCheck)(summary(), config, { format: 'json' });
+        expect(write).toHaveBeenCalled();
+        expect(JSON.parse(String(write.mock.calls[0][0])).tool).toEqual('sasjs logcheck');
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('writes annotations to stdout, and nothing when there are none', function () {
+        var write = jest
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(function () { return true; });
+        (0, renderLogCheck_1.renderLogCheck)(summary({ logs: [log({ issues: [issue()] })] }), config, {
+            format: 'annotations'
+        });
+        expect(String(write.mock.calls[0][0])).toContain('::error file=');
+        write.mockClear();
+        (0, renderLogCheck_1.renderLogCheck)(summary(), config, { format: 'annotations' });
+        expect(write).not.toHaveBeenCalled();
+    });
+    it('prints the human report by default', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderLogCheck)(summary(), config);
+        expect(output()).toContain('SASjs logcheck');
+    });
+});

package/build/commands/logcheck/types.d.ts

@@ -0,0 +1,106 @@
+import { LogIssue } from '@sasjs/utils/logs';
+/**
+ * When a log check fails. `error` is the default: an ERROR is SAS refusing to
+ * do something, and a gate red on day one gets switched off, so the notable
+ * notes legacy code produces in bulk are reported but do not fail the run.
+ */
+export type FailOn = 'error' | 'warning' | 'note' | 'never';
+/** How the result is presented. Only `human` carries colour. */
+export type OutputFormat = 'human' | 'json' | 'annotations';
+/**
+ * The policy for a log check: what fails it, and what is suppressed. The
+ * defaults are set here, a `logCheck` section in `sasjsconfig.json` may
+ * override them, and the flags on the command line override both.
+ */
+export interface LogCheckConfig {
+    /**
+     * Lowest severity that fails the check - see {@link FailOn}.
+     *
+     * `never` does not disable `maxWarnings`: a budget is a specific
+     * instruction and still fails the run when it is exceeded.
+     */
+    failOn: FailOn;
+    /**
+     * Number of warnings tolerated before the check fails, whatever `failOn`
+     * says. Undefined means no budget, which is not the same as zero.
+     */
+    maxWarnings?: number;
+    /**
+     * SAS message codes to suppress, e.g. `49-169` for the note about a
+     * quoted string being truncated. The code is the stable identifier SAS
+     * gives a message, which is what makes it the right thing to key on.
+     */
+    ignoreCodes: string[];
+    /**
+     * Log paths to leave out, as a plain substring (`sasjsresults/legacy`) or a
+     * glob (`**/build*.log`). Matched against the path shown in the report.
+     */
+    ignorePaths: string[];
+    /**
+     * Folder to check when no path is given on the command line. Resolved
+     * against the project folder.
+     */
+    folder?: string;
+    /**
+     * Whether the commands that receive a SAS log (`run`, `request`, `job
+     * execute`, `flow execute`) fail on it as well as reporting it. Off by
+     * default: those commands' exit codes are already load-bearing in pipelines,
+     * and a job that prints a notable note is not a failed job. `--logcheck` and
+     * `--no-logcheck` override it per run.
+     */
+    autoCheck?: boolean;
+}
+export declare const defaultLogCheckConfig: LogCheckConfig;
+/** Counts of the issues a log carries, after suppression. */
+export interface IssueCounts {
+    errors: number;
+    warnings: number;
+    notes: number;
+}
+export declare const emptyCounts: () => IssueCounts;
+/**
+ * One log as the check found it. A log that could not be read, is too large,
+ * or is not a SAS log carries a `skippedReason` and no issues - it is still
+ * part of the report, because a file the user asked about that was quietly
+ * dropped is worse than one reported as skipped.
+ */
+export interface ScannedLog {
+    /** Absolute path, as it was read. */
+    filePath: string;
+    /** Path as shown to the user, relative to the project folder where possible. */
+    displayPath: string;
+    /** Issues that survive the suppression rules. */
+    issues: LogIssue[];
+    /** Issues removed by `ignoreCodes`, reported only as a count. */
+    suppressed: LogIssue[];
+    counts: IssueCounts;
+    /** Set when the file was not checked at all. */
+    skippedReason?: string;
+}
+/** A file the check did not look inside, with the reason it did not. */
+export interface SkippedFile {
+    displayPath: string;
+    reason: string;
+}
+/** Everything one run of the check produced, before any rendering. */
+export interface LogCheckSummary {
+    logs: ScannedLog[];
+    skipped: SkippedFile[];
+    /** Paths the user named that do not exist. */
+    missing: string[];
+    /** Folders the check could not list, so their logs were never looked at. */
+    unreadable: SkippedFile[];
+    /** Whether the paths were defaulted rather than named by the user. */
+    usedDefaultInput: boolean;
+    /** Folders and files that were searched, as shown in the report. */
+    searched: string[];
+    totals: IssueCounts & {
+        suppressed: number;
+        /** Logs actually parsed. */
+        logs: number;
+        /** Files that were passed over, for whatever reason. */
+        skipped: number;
+    };
+    /** Why the check failed, or undefined when it passed. */
+    failure?: string;
+}

package/build/commands/logcheck/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyCounts = exports.defaultLogCheckConfig = void 0;
+exports.defaultLogCheckConfig = {
+    failOn: 'error',
+    ignoreCodes: [],
+    ignorePaths: []
+};
+var emptyCounts = function () { return ({
+    errors: 0,
+    warnings: 0,
+    notes: 0
+}); };
+exports.emptyCounts = emptyCounts;

package/build/commands/request/request.js

@@ -35,6 +35,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -145,7 +170,7 @@ function runSasJob(target, isLocal, sasJobLocation, dataFilePath, configFilePath
                                     case 4:
                                         _a.sent();
                                         _a.label = 5;
-                                    case 5: return [4 /*yield*/, saveLogFile(sasjs, sasJobLocation, logFile, jobPath)];
+                                    case 5: return [4 /*yield*/, saveLogFile(sasjs, sasJobLocation, logFile, jobPath, true)];
                                     case 6:
                                         _a.sent();
                                         result = true;
@@ -170,33 +195,47 @@ function runSasJob(target, isLocal, sasJobLocation, dataFilePath, configFilePath
         });
     });
 }
-var saveLogFile = function (sasjs, sasJobLocation, logFile, jobPath) { return __awaiter(void 0, void 0, void 0, function () {
-    var sasRequests, currentRequestLog, logPath, timestamp, filename;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                sasRequests = sasjs.getSasRequests();
-                currentRequestLog = sasRequests.find(function (x) { return x.serviceLink === sasJobLocation; });
-                if (!(currentRequestLog && jobPath)) return [3 /*break*/, 4];
-                if (!!logFile) return [3 /*break*/, 2];
-                return [4 /*yield*/, (0, utils_2.isSASjsProject)()];
-            case 1:
-                logPath = (_a.sent())
-                    ? path_1.default.join(process.sasjsConstants.buildDestinationResultsFolder, 'requests')
-                    : process.projectDir;
-                timestamp = (0, utils_1.generateTimestamp)();
-                filename = sasJobLocation.split('/').pop() // always use forward slash in SAS Drive
-                ;
-                logFile = path_1.default.join(logPath, "".concat(filename, "-").concat(timestamp, ".log"));
-                _a.label = 2;
-            case 2: return [4 /*yield*/, (0, utils_2.saveLog)(currentRequestLog.logFile, logFile, jobPath || '', false)];
-            case 3:
-                _a.sent();
-                _a.label = 4;
-            case 4: return [2 /*return*/];
-        }
+var saveLogFile = function (sasjs_1, sasJobLocation_1, logFile_1, jobPath_1) {
+    var args_1 = [];
+    for (var _i = 4; _i < arguments.length; _i++) {
+        args_1[_i - 4] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([sasjs_1, sasJobLocation_1, logFile_1, jobPath_1], __read(args_1), false), void 0, function (sasjs, sasJobLocation, logFile, jobPath, check) {
+        var sasRequests, currentRequestLog, logPath, timestamp, filename;
+        if (check === void 0) { check = false; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sasRequests = sasjs.getSasRequests();
+                    currentRequestLog = sasRequests.find(function (x) { return x.serviceLink === sasJobLocation; });
+                    if (!(currentRequestLog && jobPath)) return [3 /*break*/, 5];
+                    if (!!logFile) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, utils_2.isSASjsProject)()];
+                case 1:
+                    logPath = (_a.sent())
+                        ? path_1.default.join(process.sasjsConstants.buildDestinationResultsFolder, 'requests')
+                        : process.projectDir;
+                    timestamp = (0, utils_1.generateTimestamp)();
+                    filename = sasJobLocation.split('/').pop() // always use forward slash in SAS Drive
+                    ;
+                    logFile = path_1.default.join(logPath, "".concat(filename, "-").concat(timestamp, ".log"));
+                    _a.label = 2;
+                case 2: return [4 /*yield*/, (0, utils_2.saveLog)(currentRequestLog.logFile, logFile, jobPath || '', false)
+                    // after the write, not before: a request that fails the check is the one
+                    // whose log is wanted on disk
+                ];
+                case 3:
+                    _a.sent();
+                    if (!check) return [3 /*break*/, 5];
+                    return [4 /*yield*/, (0, utils_2.checkLog)(currentRequestLog.logFile, sasJobLocation)];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5: return [2 /*return*/];
+            }
+        });
     });
-}); };
+};
 /**
  * Writes output to the file
  * @param outputPathParam path to output file