TypeScript Logger.error方法代码示例

export async function call<Params, Res>(
  store: Store,
  logger: Logger,
  rc: RequestCreator<Params, Res>,
  params: Params,
  setup?: SetupFunc
): Promise<Res> {
  const client = await getClient(store, logger);

  try {
    logger.debug(`🙏 ${rc({} as any)(client).method}`);
    return await client.call(rc, params, setup);
  } catch (e) {
    if (isCancelled(e)) {
      // nvm
    } else if (isAborted(e)) {
      // nvm
    } else {
      logger.error(`Caught butler error:`);
      if (isInternalError(e)) {
        const ed = getRpcErrorData(e);
        if (ed) {
          logger.error(`butler version: ${ed.butlerVersion}`);
          logger.error(`Golang stack:\n${ed.stack}`);
        }
        logger.error(`JavaScript stack: ${e.stack}`);
      } else {
        logger.error(`${e.message}`);
      }
    }
    throw e;
  }
}

 setImmediate(() => {
   try {
     f();
   } catch (e) {
     this.logger.error(`In scheduled stateChange: ${e.stack}`);
   }
 });

    this.addWatcher(actionName, async (store, action) => {
      let rs = store.getState();
      if (rs === oldRs) {
        return;
      }
      oldRs = rs;

      if (!selector) {
        const schedule: Schedule = f => {
          setImmediate(() => {
            try {
              f();
            } catch (e) {
              this.logger.error(`In scheduled stateChange: ${e.stack}`);
            }
          });
        };
        schedule.dispatch = (action: Action<any>) => {
          schedule(() => store.dispatch(action));
        };
        selector = makeSelector(store, schedule);
      }

      try {
        selector(rs);
      } catch (e) {
        this.logger.error(`In state selector: ${e.stack}`);
      }
    });

 private onMessage(logger: Logger, msg: ISM) {
   if (msg.type === "no-update-available") {
     this.stage("idle");
   } else if (msg.type === "installing-update") {
     this.stage("download");
   } else if (msg.type === "update-failed") {
     const pp = msg.payload as ISM_UpdateFailed;
     logger.error(`Self-update failed: ${pp.message}`);
   } else if (msg.type === "update-ready") {
     const pp = msg.payload as ISM_UpdateReady;
     logger.info(`Version ${pp.version} is ready to be used.`);
     this.store.dispatch(
       actions.packageNeedRestart({
         name: this.name,
         availableVersion: pp.version,
       })
     );
   } else if (msg.type === "progress") {
     const pp = msg.payload as ISM_Progress;
     this.store.dispatch(
       actions.packageProgress({
         name: this.name,
         progressInfo: pp,
       })
     );
   } else if (msg.type === "log") {
     const pp = msg.payload as ISM_Log;
     logger.info(`> ${pp.message}`);
   }
 }

function err(logger: Logger, e: Error, action: Action<any>) {
  if (isCancelled(e)) {
    console.warn(`reactor for ${action.type} was cancelled`);
  } else {
    const actionName = (action || { type: "?" }).type;
    const errorStack = e.stack || e;
    const msg = `while reacting to ${actionName}: ${errorStack}`;
    logger.error(msg);
  }
}

 convo.on(messages.Log, async ({ level, message }) => {
   switch (level) {
     case "debug":
       logger.debug(message);
       break;
     case "info":
       logger.info(message);
       break;
     case "warning":
       logger.warn(message);
       break;
     case "error":
       logger.error(message);
       break;
     default:
       logger.info(`[${level}] ${message}`);
       break;
   }
 });

export async function downloadToFile(
  onProgress: (progress: ProgressInfo) => void,
  logger: Logger,
  url: string,
  file: string
) {
  const dir = dirname(file);
  try {
    await sf.mkdirp(dir);
  } catch (e) {
    logger.error(`Could not create ${dir}: ${e.message}`);
  }

  const fileSink = sf.createWriteStream(file, {
    flags: "w",
    mode: 0o777,
    defaultEncoding: "binary",
  }) as WriteStream;
  try {
    let totalSize = 0;

    let progressStream: NodeJS.ReadWriteStream;
    await request(
      "get",
      url,
      {},
      {
        sink: () => {
          progressStream = progress({ length: totalSize, time: 500 });
          progressStream.on("progress", info => {
            onProgress({
              progress: info.percentage / 100,
              eta: info.eta,
              bps: info.speed,
              doneBytes: (info.percentage / 100) * totalSize,
              totalBytes: totalSize,
            });
            logger.info(
              `${info.percentage.toFixed(1)}% done, eta ${info.eta.toFixed(
                1
              )}s @ ${fileSize(info.speed)}/s`
            );
          });
          progressStream.pipe(fileSink);
          return progressStream;
        },
        cb: res => {
          logger.info(`HTTP ${res.statusCode} ${url}`);
          if (!/^2/.test("" + res.statusCode)) {
            const e = new Error(`HTTP ${res.statusCode} ${url}`) as HTTPError;
            e.httpStatusCode = res.statusCode;
            throw e;
          }

          const contentLengthHeader = res.headers["content-length"];
          if (!isEmpty(contentLengthHeader)) {
            totalSize = parseInt(contentLengthHeader[0], 10);
          }
        },
      }
    );
    await sf.promised(fileSink);

    const stats = await sf.lstat(file);
    logger.info(
      `Downloaded ${fileSize(stats.size)} / ${fileSize(totalSize)} (${
        stats.size
      } bytes)`
    );

    if (totalSize !== 0 && stats.size !== totalSize) {
      throw new Error(`download failed (short size) for ${url}`);
    }
  } finally {
    fileSink.end();
  }
}