PTN1 補足した例外を記録後再throwする。

let someLogPtn1 = (e: Error) => {
    // some log code;
    console.log("logging:" + e.message);
    throw e;
}

補足したerrorを再放流しています。別な箇所でまたログを記録してしまい、二重ログになる可能性があります。

PTN2 新しいエラーを作って返すことにより、ログの二重記録を防ぐ

let someLogPtn2 = (e: Error) => {
    if (e instanceof LoggerError) {
        return;
    }
    // some log code;
    console.log("logging:" + e.message);
    throw new LoggerError(e.toString());
}

懸念点：新規に関わった開発者に説明が必要になる。

PTN3 エラーをthrowする以外の方法で終了する

例えば、process.exit(1);で終了させます。
AWS Lambdaにおいて使おうとしていますが、これによる影響が読めず悩んでいます。

let someLogPtn3 = (e: Error) => {
    // some log code;
    console.log("logging:" + e.message);
    // とにかく異常終了させる
    process.exit(1);
}

まとめ

自分はPTN3がいいような気がしますが、Lambdaで使う上での懸念点や、そもそも
process.exit(1); 以外の推奨方法はありますでしょうか？

以下がSampleコード全体となります。

let main = () => {
    try {
        runAndError();
    } catch (e) {
        errorHandler(e);
    }
}

main();

let runAndError = () => {
    throw new Error("someError");
}


class LoggerError extends Error { 
    constructor(e: string) {
        super(e);
    }
}


// ptn1: そのまま返す
// 懸念点: また上位の階層でlogに記録してしまうんじゃないか？

let someLogPtn1 = (e: Error) => {
    // some log code;
    console.log("logging:" + e.message);
    throw e;
}

// ptn2: 新しいエラーを作って返す。それによってそれによってログの二重記録を防ぐ
// 懸念点： 新規に関わった開発者に説明が必要になる。
let someLogPtn2 = (e: Error) => {
    if (e instanceof LoggerError) {
        return;
    }
    // some log code;
    console.log("logging:" + e.message);
    throw new LoggerError(e.toString());
}

// ptn3: エラーををthrowする以外の方法で終了する
// これがいいような気がしますが、予想がつかず
let someLogPtn3 = (e: Error) => {
    // some log code;
    console.log("logging:" + e.message);
    // とにかく異常終了させる
    process.exit(1);
}


let errorHandler = (e: Error) => {
    // ptn1: そのまま返す
    // 懸念点: また上位の階層でlogに記録してしまうんじゃないか？
    someLogPtn1(e)；

    // ptn2: 新しいエラーを作って返す。それによってそれによってログの二重記録を防ぐ
    // 懸念点： 新規に関わった開発者に説明が必要になる。
    someLogPtn2（e）；

    // ptn3: エラーををthrowする以外の方法で終了する
    // これがいいような気がしますが、予想がつかず
    someLogPtn3（e）；
}