@applicaster/zapp-react-native-utils/logger/const.ts

Applicaster Zapp React Native utilities package

/* eslint-disable unused-imports/no-unused-vars */
import * as R from "ramda";

enum XRayLogLevel {
  verbose = 0,
  debug = 1,
  info = 2,
  warning = 3,
  warn = 3,
  error = 4,
  off = 100,
}

enum ToastLogLevel {
  off = "off",
  verbose = "verbose",
  debug = "debug",
  info = "info",
  warning = "warning",
  error = "error",
}

const toastLevelToLogLevel = (toastLogLevel: ToastLogLevel): XRayLogLevel => {
  if (R.isNil(toastLogLevel)) {
    return XRayLogLevel.off;
  }

  switch (toastLogLevel) {
    case ToastLogLevel.verbose:
      return XRayLogLevel.verbose;
    case ToastLogLevel.debug:
      return XRayLogLevel.debug;
    case ToastLogLevel.info:
      return XRayLogLevel.info;
    case ToastLogLevel.error:
      return XRayLogLevel.error;
    default:
      return XRayLogLevel.off;
  }
};

const PLUGIN_IDENTIFIER = "xray_logging_plugin";

const wrapInObject = (obj, name) => {};

const applyConditions = (wrappedObj) => {};

const sanitizeEventPayload = () => {};

const __isRunningRepoTests = () => {};

const isWeb = () => {};

const isDOMApp = () => {};

const isBrowser = () => {};

const eventAllowed = () => {};

/**
 * This is the mocked version of XRayLogger
 * It was created as a part of our dynamically imported usage of Xray
 * Otherwise we would have to add optional conditions to every use of xray
 * This may not be the solution we are looking for
 * */
export default class XRayLogger {
  private category: string;
  private subsystem: string;
  private context: {};
  private parent: XRayLogger;
  static mock: boolean = true;

  static logLevels = XRayLogLevel;

  constructor(category: string, subsystem: string, parent?: XRayLogger) {
    this.category = category;
    this.subsystem = subsystem;
    this.context = {};
    this.parent = parent || null;
    this.addContext({});
    this.addSubsystem = this.addSubsystem.bind(this);
  }

  addSubsystem = (subsystem: string): XRayLogger => {
    // @ts-ignore
    return new XRayLogger(
      this.category,
      `${this.subsystem}/${subsystem}`,
      this
    );
  };

  log = (event: string | XRayEventData) => {
    const logEvent = typeof event === "string" ? { message: event } : event;
  };

  debug = (event: string | XRayEventData) => {
    const logEvent = typeof event === "string" ? { message: event } : event;
  };

  info = (event: string | XRayEventData) => {
    const logEvent = typeof event === "string" ? { message: event } : event;
  };

  warning = (event: string | XRayEventData) => {
    const logEvent = typeof event === "string" ? { message: event } : event;
  };

  warn = (event: string | XRayEventData) => {
    this.warning(event);
  };

  error = (event: Error | XRayEventData) => {
    const logEvent: XRayEventData =
      event instanceof Error
        ? { exception: event as Error, message: event.message }
        : (event as XRayEventData);
  };

  sendEvent = (event, eventData) => {};

  // To be used by QuickBrick Hook events
  sendAudienceEvent = (event, eventData = null) => {
    this.sendEvent(event, eventData);
  };

  getContext = () => {
    return Object.assign({}, this.parent?.getContext() || {}, this.context);
  };

  addContext = (context): this => {
    try {
      const newContext = Object.assign(
        {},
        this.getContext(),
        applyConditions(wrapInObject(context, "context"))
      );

      this.context = newContext;
    } catch (e) {
      // Failed to add context
    }

    return this;
  };

  createEvent = () => {
    return () => {};
  };
}