How to use stack-trace - 10 common examples

private static getCaller(): string {
        // get the stack trace above logInner. casting is necessary because the stack trace package only accepts () => void functions.
        const stack = Stacktrace.get(Log.logInner as unknown as () => void);
        // 6 frames is the magic number to get around __awaiters, past the Log.x function, and up to the frame we care about.
        const frame = stack[6];
        if (frame == null) {
            return "N/A";
        }

        let methodName = frame.getMethodName() || frame.getFunctionName();
        if (methodName != null) {
            // If it's a callback, there will be extra stuff we aren't interested in separated by dots
            // eg "Project.__dirname.constructor.connection.update"
            // strip out everything up to the last dot, if there is one
            const splitByPeriod: string[] = methodName.split(".");
            if (splitByPeriod.length > 1) {
                methodName = splitByPeriod[splitByPeriod.length - 1];
            }
            methodName = `.${methodName}()`;

constructor (level, source) {
    if (!level) {
      throw new Error('Level is missing.');
    }

    /* eslint-disable global-require */
    const flaschenpost = require('../flaschenpost');
    /* eslint-enable global-require */

    const options = {};

    options.objectMode = true;
    options.source = source || stackTrace.get()[1].getFileName();

    super(options);

    this.level = level;
    this.logger = flaschenpost.getLogger(options.source);

    if (!this.logger[this.level]) {
      throw new Error('Level is invalid.');
    }
  }

private getCallerFileAndLineTag(): string {
        const frame: StackTrace.StackFrame[] = StackTrace.parse(new Error());
        let callerStackIndex = 1;
        while (frame[callerStackIndex].getFileName().indexOf(path.basename(__filename)) >= 0) {
            // go up the stack until we're outside of the BrightsideLogger file
            callerStackIndex += 1;
        }
        const filename = path.basename(frame[callerStackIndex].getFileName());
        const lineNumber = frame[callerStackIndex].getLineNumber();
        return format("[%s:%s] ", filename, lineNumber);
    }

function parseV8(error) {
  assert.ok(error instanceof Error);
  var parsed = stackTrace.parse(error);
  return parsed.map(function(entry) {
    var e = _.pick(entry, 'fileName', 'lineNumber', 'columnNumber', 'native');
    // Flag entries that originated in eval'd webppl code. These will
    // be looked up in the source map later.
    e.webppl = entry.fileName === '';
    // v8 column numbers are one indexed. Standardize on zero-based
    // indexed as this is used by the source map library.
    if (entry.columnNumber !== null) {
      e.columnNumber = entry.columnNumber - 1;
    }
    e.name = null;
    return e;
  });
}

function findCallLocation(functionName: string): Location | undefined {

	const stackTrace = parseStackTrace(new Error());

	for (var i = 0; i < stackTrace.length - 1; i++) {
		if (stackTrace[i].getFunctionName() === functionName) {
			const callSite = stackTrace[i + 1];
			return {
				file: callSite.getFileName(),
				line: callSite.getLineNumber() - 1
			};
		}
	}

	return undefined;
}

private stackTraceOf(error: Error): Array {
        return parse(error).map((frame) => {
            return {
                declaringClass: frame.getTypeName() || frame.getFunctionName() || '',
                methodName:     frame.getMethodName() || frame.getFunctionName() || '',
                fileName:       frame.getFileName(),
                lineNumber:     frame.getLineNumber()
            }
        });
    }

runner.on('fail', (test: Mocha.ITest, err: Error & { actual?: any, expected?: any, showDiff?: boolean }) => {

				const testId = `${test.file}: ${test.fullTitle()}`;
				const description = getElapsedTime(testId);

				let decorations: TestDecoration[] = [];
				if (err.stack) {
					const parsedStack = stackTrace.parse(err);
					for (const stackFrame of parsedStack) {
						let filename = stackFrame.getFileName();
						if (typeof filename === 'string') {
							filename = path.resolve(filename);
							let matchFound = false;
							if (sloppyMatch && test.file) {
								const f1 = filename.substring(0, filename.length - path.extname(filename).length);
								const f2 = test.file.substring(0, test.file.length - path.extname(test.file).length);
								if (f1 === f2) {
									matchFound = true;
								}
							} else {
								if (filename === test.file) {
									matchFound = true;
								}
							}

export default function (folder, recursive = false, pattern = patternDefault, parentDir = undefined) {
  folder = path.normalize(folder)
  if (!parentDir) {
    parentDir = path.dirname(stackTrace.get()[1].getFileName())
  }
  const contextDir = path.join(parentDir, folder)
  const contextDirLen = contextDir.length + 1
  const normalizedFolder = path.resolve(parentDir, folder)
  const folderContents = getFolderContents(normalizedFolder, recursive)
    .filter(item => {
      return pattern.test(item)
    })
    .map(item => {
      return '.' + SEP + item.substr(contextDirLen)
    })

  const keys = function () {
    return folderContents
  }

export function callsite(logInfo: logform.TransformableInfo): logform.TransformableInfo {
    const oldLimit = Error.stackTraceLimit;
    try {
        Error.stackTraceLimit = Infinity;
        throw new Error();
    } catch (e) {
        const root = appRoot.path;
        const callsites = trace.parse(e).map(l => ({
            fileName: l.getFileName(),
            lineNumber: l.getLineNumber(),
        })).filter(cs => !!cs.fileName).reverse();
        const callsite = callsites[callsites.findIndex(cs => cs.fileName.includes("node_modules/winston")) - 1];
        if (!!callsite) {
            return {
                ...logInfo,
                callsite: {
                    ...callsite,
                    fileName: callsite.fileName.split(root)[1].slice(1),
                },
            };
        }
    } finally {
        Error.stackTraceLimit = oldLimit;
    }

public mutate(options: MutationOptions<q> | string): Promise {
        if (typeof options === "string") {
            options = {
                name: options,
            };
        }
        const m = internalGraphql.mutate({
            mutation: options.mutation,
            path: options.path,
            name: options.name,
            moduleDir: (options as any).moduleDir ? (options as any).moduleDir : trace.get()[1].getFileName(),
        });
        return this.executeMutation(m, options.variables, options.options);
    }
</q>