### Install react-native-logs with npm

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Use this command to install the library using npm.

```sh
npm install --save react-native-logs
```

--------------------------------

### Install react-native-logs with expo

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Use this command to install the library with Expo.

```sh
expo install react-native-logs
```

--------------------------------

### Install react-native-logs with yarn

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Use this command to install the library using yarn.

```sh
yarn add react-native-logs
```

--------------------------------

### Global Logger Setup in React Native

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Initialize a global logger in a `config.js` file for easy import across your application. This example demonstrates setting up transports, severity levels, and color options.

```javascript
//config.js
import {
  logger,
  consoleTransport,
  fileAsyncTransport,
} from "react-native-logs";
import RNFS from "react-native-fs";

var LOG = logger.createLogger({
  transport: __DEV__ ? consoleTransport : fileAsyncTransport,
  severity: __DEV__ ? "debug" : "error",
  transportOptions: {
    colors: {
      info: "blueBright",
      warn: "yellowBright",
      error: "redBright",
    },
    FS: RNFS,
  },
});

export { LOG };
```

```javascript
//index.js and other app files
import { LOG } from "./config";

LOG.info("app log test");
```

```javascript
//root.js
import { LOG } from "./config";
var log = LOG.extend("ROOT");

log.info("root log test");
```

```javascript
//root2.js
import { LOG } from "./config";
var log = LOG.extend("ROOT");

log.info("root log test");
```

```javascript
//home.js
import { LOG } from "./config";
var log = LOG.extend("HOME");

log.info("home log test");
```

--------------------------------

### Quick Start: Create and Use a Logger

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

This snippet demonstrates how to create a default logger and log messages at different severity levels (debug, info, warn, error). The default logger uses the console transport.

```javascript
import { logger } from "react-native-logs";

var log = logger.createLogger();

log.debug("This is a Debug log");
log.info("This is an Info log");
log.warn("This is a Warning log");
log.error("This is an Error log");
```

--------------------------------

### Create a Fully Configured Logger Instance

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Use `logger.createLogger` to set up a logger with custom levels, severity, transports, and formatting options. This example demonstrates configuring console output with specific colors and enabling asynchronous logging.

```typescript
import { logger, consoleTransport } from "react-native-logs";

// Fully configured logger (TypeScript infers level methods from the levels object)
const log = logger.createLogger({
  levels: {
    trace: 0,
    debug: 1,
    info: 2,
    warn: 3,
    error: 4,
  },
  severity: "debug",           // Minimum level to display
  transport: consoleTransport,
  transportOptions: {
    colors: {
      trace: "grey",
      debug: "cyan",
      info: "blueBright",
      warn: "yellowBright",
      error: "redBright",
    },
  },
  async: true,                 // Defer via requestIdleCallback / setTimeout
  dateFormat: "iso",           // "time" | "local" | "utc" | "iso" | (date) => string
  printLevel: true,
  printDate: true,
  fixedExtLvlLength: true,     // Pad level/extension names for column alignment
  enabled: true,
});

log.trace("Starting up");
log.debug("Loaded config", { endpoint: "https://api.example.com" });
log.info("User authenticated", { userId: 42 });
log.warn("Retry attempt", { attempt: 2 });
log.error("Request failed", new Error("Network timeout"));
// Output: "2024-01-15T10:23:45.123Z | TRACE : Starting up"
//         "2024-01-15T10:23:45.124Z | DEBUG : Loaded config \n{ \"endpoint\": ... }\n"
```

--------------------------------

### Using Multiple Transports

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Configure the logger to use multiple transports simultaneously by passing an array of transport functions. This example includes console, file, Sentry, Crashlytics, and a custom transport.

```javascript
import {
  logger,
  consoleTransport,
  fileAsyncTransport,
  sentryTransport,
  crashlyticsTransport,
  transportFunctionType,
} from "react-native-logs";
import RNFS from "react-native-fs";
import * as Sentry from "@sentry/react-native";
import crashlytics from "@react-native-firebase/crashlytics";

const crashlyticsModule = crashlytics();

var customTransport: transportFunctionType = (props) => {
  // Do here whatever you want with the log message
  // Eg. a console log: console.log(props.level.text, props.msg)
};

const log = logger.createLogger({
  transport: [
    consoleTransport,
    fileAsyncTransport,
    sentryTransport,
    crashlyticsTransport,
    customTransport,
  ],
  transportOptions: {
    FS: RNFS,
    SENTRY: Sentry,
    CRASHLYTICS: crashlyticsModule,
    colors: {
      info: "blueBright",
      warn: "yellowBright",
      error: "redBright",
    },
  },
});
```

--------------------------------

### Crashlytics Transport Example

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Demonstrates how to configure and use the crashlyticsTransport to send logs to Firebase Crashlytics.

```APIDOC
## Crashlytics Transport Example

### Description
This example shows how to set up the `crashlyticsTransport` to send specific log levels to Firebase Crashlytics.

### Method
`logger.createLogger` with `transport: crashlyticsTransport`

### Configuration Options
- `transport`: `crashlyticsTransport`
- `transportOptions.CRASHLYTICS`: Instance of `@react-native-firebase/crashlytics`
- `transportOptions.errorLevels`: String specifying which log levels to send as errors (e.g., "error")

### Request Example
```javascript
import { logger, crashlyticsTransport } from "react-native-logs";
import crashlytics from "@react-native-firebase/crashlytics";

var log = logger.createLogger({
  transport: crashlyticsTransport,
  transportOptions: {
    CRASHLYTICS: crashlytics(),
    errorLevels: "error",
  },
});

log.warn("Send this log to Crashlytics as log message");
log.error("Send this log to Crashlytics as non-fatal error");
```
```

--------------------------------

### TypeScript Level Typing Example

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Demonstrates how TypeScript enforces log level types based on the logger configuration. Ensure 'logger' is imported from 'react-native-logs'.

```typescript
import { logger } from "react-native-logs";

var log = logger.createLogger({
  levels: {
    trace: 0,
    info: 1,
    error: 2,
  },
});

log.trace("message"); // correct log call

log.silly("message"); // typescript error, "silly" method does not exist
```

--------------------------------

### Send Logs to Crashlytics

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Configure and send logs to Firebase Crashlytics. Ensure '@react-native-firebase/crashlytics' is installed and configured.

```javascript
import { logger, crashlyticsTransport } from "react-native-logs";
import crashlytics from "@react-native-firebase/crashlytics";

var log = logger.createLogger({
  transport: crashlyticsTransport,
  transportOptions: {
    CRASHLYTICS: crashlytics(),
    errorLevels: "error",
  },
});

log.warn("Send this log to Crashlytics as log message");
log.error("Send this log to Crashlytics as non-fatal error");
```

--------------------------------

### Conditional Logging in Development Mode

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Configure logs to only appear in development mode using the `__DEV__` global variable. This setup uses `consoleTransport` in development and `fileAsyncTransport` in production, adjusting severity accordingly.

```javascript
import {
  logger,
  consoleTransport,
  fileAsyncTransport,
} from "react-native-logs";
import RNFS from "react-native-fs";

const config = {
  transport: __DEV__ ? consoleTransport : fileAsyncTransport,
  severity: __DEV__ ? "debug" : "error",
  transportOptions: {
    colors
    FS: RNFS,
  },
};

var log = logger.createLogger();
```

--------------------------------

### Get Original Console Object

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Retrieve the original console object if it was replaced by 'patchConsole'. This allows direct use of standard console methods.

```javascript
var originalConsole = log.getOriginalConsole();
originalConsole.log("This will use the standard console.log");
```

--------------------------------

### Set and Get Log Severity Level

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Control which log messages are displayed by setting the minimum severity level. 'setSeverity' overwrites the initial configuration.

```javascript
var log = logger.createLogger();

log.setSeverity("info");
log.debug("This log will not be printed");
log.info("This log will be printed correctly");
log.error("This log will be printed correctly");
```

```javascript
var log = logger.createLogger();

var defaultseverity = log.getSeverity(); // severity = debug
log.setSeverity("info");
var severity = log.getSeverity(); // severity = info
log.setSeverity("error");
var newseverity = log.getSeverity(); // newseverity = error
```

--------------------------------

### Custom `formatFunc` for JSON Output

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Use `formatFunc` to define a completely custom log message format. This example creates JSON lines, suitable for log aggregation systems. Ensure the `transport` is set to `consoleTransport` or another suitable transport.

```typescript
import { logger, consoleTransport } from "react-native-logs";

const log = logger.createLogger({
  transport: consoleTransport,
  // Fully custom format: JSON lines for log aggregation
  formatFunc: (level, extension, msgs) => {
    const combined = Array.isArray(msgs)
      ? msgs.map((m) => (typeof m === "object" ? JSON.stringify(m) : String(m))).join(" ")
      : String(msgs);
    return JSON.stringify({
      ts:  new Date().toISOString(),
      lvl: level,
      ns:  extension ?? undefined,
      msg: combined,
    });
  },
  // Or, keep default format but customize value serialization:
  // stringifyFunc: (val) => (val instanceof Error ? val.stack ?? val.message : JSON.stringify(val)),
});

log.info("User signed in", { userId: 7, plan: "pro" });
// Output: {"ts":"2024-01-15T10:00:00.000Z","lvl":"info","msg":"User signed in {\"userId\":7,\"plan\":\"pro\"}"}

const apiLog = log.extend("API");
apiLog.error("Rate limited", { retryAfter: 30 });
// Output: {"ts":"...","lvl":"error","ns":"API","msg":"Rate limited {\"retryAfter\":30}"}
```

--------------------------------

### Sentry Transport for react-native-logs

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Forwards log messages to a Sentry instance. Levels in `errorLevels` are sent as captured exceptions; others are breadcrumbs. Requires `@sentry/react-native` to be installed and initialized separately.

```typescript
import { logger, sentryTransport } from "react-native-logs";
import * as Sentry from "@sentry/react-native";

Sentry.init({ dsn: "https://your-dsn@sentry.io/project-id" });

const log = logger.createLogger({
  severity: "info",
  transport: sentryTransport,
  transportOptions: {
    SENTRY: Sentry,
    errorLevels: ["error", "fatal"],  // or a single string: "error"
  },
});

log.info("Payment flow started");           // → Sentry breadcrumb
log.warn("Slow network detected");          // → Sentry breadcrumb
log.error("Payment gateway unreachable");   // → Sentry captureException
```

--------------------------------

### Custom Transport Function for react-native-logs

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Implement a custom transport function that matches `transportFunctionType`. It receives formatted message, raw message, level, extension, and options. This example sends logs to a remote endpoint via fetch.

```typescript
import { logger, transportFunctionType } from "react-native-logs";

interface RemoteLogOptions {
  endpoint: string;
  appVersion: string;
}

const remoteTransport: transportFunctionType<RemoteLogOptions> = (props) => {
  if (!props.options?.endpoint) return;

  fetch(props.options.endpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      level:      props.level.text,
      severity:   props.level.severity,
      message:    props.msg,
      raw:        props.rawMsg,
      namespace:  props.extension ?? "root",
      appVersion: props.options.appVersion,
      timestamp:  new Date().toISOString(),
    }),
  }).catch(console.error);
};

const log = logger.createLogger({
  transport: remoteTransport,
  transportOptions: {
    endpoint:   "https://logs.example.com/ingest",
    appVersion: "3.2.1",
  },
});

log.error("Unexpected state", { screen: "Cart", userId: 42 });
// POSTs: { level: "error", severity: 3, message: "...", namespace: "root", ... }
```

--------------------------------

### Use Map Console Transport

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Import and use the `mapConsoleTransport` preset. This transport allows mapping log levels to specific console methods.

```javascript
import { logger, mapConsoleTransport } from "react-native-logs";

var log = logger.createLogger({
  transport: mapConsoleTransport,
});

log.debug("Debug message");

```

--------------------------------

### Extensions (Namespaced Loggers)

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Illustrates how to create and use namespaced loggers to selectively enable logging for different parts of your application.

```APIDOC
## Extensions (Namespaced Loggers)

### Description
Extend the logger to different namespaces for granular control over logging. Extensions can be enabled via configuration or dynamic methods.

### Method
`logger.extend(namespace)`

### Configuration Options
- `enabledExtensions`: Array of strings specifying which extensions are enabled by default (e.g., `["ROOT", "HOME"]`)

### Request Example
```javascript
import { logger, consoleTransport } from "react-native-logs";

var log = logger.createLogger({
  transport: consoleTransport,
  enabledExtensions: ["ROOT", "HOME"],
});

var rootLog = log.extend("ROOT");
var homeLog = log.extend("HOME");
var profileLog = log.extend("PROFILE");

log.debug("print this"); // Prints with default namespace
rootLog.debug("print this"); // Prints with ROOT namespace
homeLog.debug("print this"); // Prints with HOME namespace
profileLog.debug("not print this"); // Does not print as PROFILE is not enabled
```
```

--------------------------------

### getExtensions

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Retrieves an array of all currently created logger extensions.

```APIDOC
## getExtensions

### Description
Get an array of currently created extensions.

### Method
`log.getExtensions()`

### Returns
- `Array<string>`: An array containing the names of the currently created extensions.
```

--------------------------------

### Configure Console Transport

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Set up the default console transport with custom log level mapping. This is useful for debugging and development.

```javascript
import { logger, mapConsoleTransport } from "react-native-logs";

var log = logger.createLogger({
  levels: {
    debug: 0,
    info: 1,
    warn: 2,
    err: 3,
  },
  transport: mapConsoleTransport,
  transportOptions: {
    mapLevels: {
      debug: "log",
      info: "info",
      warn: "warn",
      err: "error",
    },
  },
});

log.debug("Print this with console.log");
log.err("Print this with console.error");
```

--------------------------------

### Asynchronous Logging for Performance

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Improve application performance by enabling asynchronous logging with `async: true`. The library automatically uses `requestIdleCallback` or `setTimeout` to defer logging, preventing UI thread blocking.

```javascript
// Example configuration for async logging (actual code not shown, but concept explained in text)
// logger.createLogger({
//   async: true,
//   // ... other configurations
// });
```

--------------------------------

### Configure Console Transport with Colors and Extensions

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Customize the `consoleTransport` by setting colors for log levels and extension namespaces. This allows for visually distinct log outputs.

```javascript
import { logger, consoleTransport } from "react-native-logs";

var log = logger.createLogger({
  levels: {
    debug: 0,
    info: 1,
    warn: 2,
    error: 3,
  },
  transport: consoleTransport,
  transportOptions: {
    colors: {
      info: "blueBright",
      warn: "yellowBright",
      error: "redBright",
    },
    extensionColors: {
      root: "magenta",
      home: "green",
    },
  },
});

var rootLog = log.extend("root");
var homeLog = log.extend("home");

rootLog.info("Magenta Extension and bright blue message");
homeLog.error("Green Extension and bright red message");

```

--------------------------------

### Configure Logger with Common Options

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Use this snippet to set up the logger with custom log levels, severity, transport, and formatting options. Ensure 'react-native-logs' and 'consoleTransport' are imported.

```javascript
import { logger, consoleTransport } from "react-native-logs";

var log = logger.createLogger({
  levels: {
    debug: 0,
    info: 1,
    warn: 2,
    error: 3,
  },
  severity: "debug",
  transport: consoleTransport,
  transportOptions: {
    colors: {
      info: "blueBright",
      warn: "yellowBright",
      error: "redBright",
    },
  },
  async: true,
  dateFormat: "time",
  printLevel: true,
  printDate: true,
  fixedExtLvlLength: false,
  enabled: true,
});

log.debug("Debug message");
log.info({ message: "hi!" });
```

--------------------------------

### Configure File Async Transport

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Set up the fileAsyncTransport to save logs to a file. Requires `react-native-fs` or `expo-file-system`. Logs can be organized by date in the filename.

```javascript
import { logger, fileAsyncTransport } from "react-native-logs";
import RNFS from "react-native-fs";
/* EXPO:
 * import * as FileSystem from 'expo-file-system';
 */

let today = new Date();
let date = today.getDate();
let month = today.getMonth() + 1;
let year = today.getFullYear();

var log = logger.createLogger({
  severity: "debug",
  transport: fileAsyncTransport,
  transportOptions: {
    FS: RNFS,
    /* EXPO:
     * FS: FileSystem,
     */
    fileName: `logs_{date-today}`, // Create a new file every day
  },
});

log.info("Print this string to a file");
```

--------------------------------

### Extend Logger with Namespaces

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Create namespaced loggers using the 'extend' method to selectively enable logging for different app parts. Enabled extensions are configured via 'enabledExtensions'.

```javascript
import { logger, consoleTransport } from "react-native-logs";

var log = logger.createLogger({
  transport: consoleTransport,
  enabledExtensions: ["ROOT", "HOME"],
});

var rootLog = log.extend("ROOT");
var homeLog = log.extend("HOME");
var profileLog = log.extend("PROFILE");

log.debug("print this"); // this will print "<time> | DEBUG | print this"
rootLog.debug("print this"); // this will print "<time> | ROOT | DEBUG | print this"
homeLog.debug("print this"); // this will print "<time> | HOME | DEBUG | print this"
profileLog.debug("not print this"); // this extension is not enabled
```

--------------------------------

### enable/disable Methods

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Dynamically enable or disable loggers and their extensions.

```APIDOC
## enable/disable

### Description
Dynamically enable or disable loggers and extensions. Calling without parameters disables/enables the entire logger.

### Method
`log.enable(extensionName)`
`log.disable(extensionName)`

### Usage
- `log.disable()`: Disables the entire logger.
- `log.disable("EXTENSION_NAME")`: Disables a specific extension.

### Request Example
```javascript
import { logger, consoleTransport } from "react-native-logs";

var log = logger.createLogger({
  transport: consoleTransport,
  enabledExtensions: ["ROOT", "HOME"],
});

var rootLog = log.extend("ROOT");
var homeLog = log.extend("HOME");

log.info("print this"); // Prints
homeLog.info("print this"); // Prints

log.disable("HOME");

homeLog.info("not print this"); // Does not print
rootLog.info("print this"); // Prints

log.disable();

homeLog.info("not print this"); // Does not print
rootLog.info("not print this"); // Does not print
log.info("not print this"); // Does not print
```
```

--------------------------------

### Configure Colored Console Output with Extensions

Source: https://context7.com/mowispace/react-native-logs/llms.txt

The `consoleTransport` allows customization of colors for log levels and extensions. Use `log.extend()` to create namespaced loggers with distinct color labels for better output organization.

```typescript
import { logger, consoleTransport } from "react-native-logs";

const log = logger.createLogger({
  transport: consoleTransport,
  transportOptions: {
    colors: {
      debug: "cyan",
      info: "blueBright",
      warn: "yellowBright",
      error: "redBright",
    },
    extensionColors: {
      AUTH: "magentaBright",
      API:  "greenBright",
    },
    // Optional: replace console.log with a custom sink
    consoleFunc: (msg: string) => myCustomSink.write(msg),
  },
});

const authLog = log.extend("AUTH");
const apiLog  = log.extend("API");

authLog.info("Token refreshed");   // Magenta "AUTH" label, blue message
apiLog.error("404 Not Found");     // Green "API" label, red message
log.warn("Disk space low");        // No extension label, yellow message
```

--------------------------------

### log.extend(namespace)

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Creates a child logger that tags every message with a given namespace string. These extensions can be selectively enabled or disabled at runtime.

```APIDOC
## `log.extend(namespace)` — Namespaced (extension) loggers

Creates a child logger that tags every message with the given namespace string. Extensions can be selectively enabled or disabled via `enabledExtensions` config or the `enable`/`disable` methods at runtime.

```typescript
import { logger, consoleTransport } from "react-native-logs";

const log = logger.createLogger({
  transport: consoleTransport,
  enabledExtensions: ["AUTH", "API"],   // PROFILE is created but silent
  transportOptions: {
    extensionColors: { AUTH: "magenta", API: "cyan" },
  },
});

const authLog    = log.extend("AUTH");
const apiLog     = log.extend("API");
const profileLog = log.extend("PROFILE");

authLog.info("Login successful");      // prints: "10:00:01 | AUTH | INFO : Login successful"
apiLog.debug("GET /users/42");         // prints: "10:00:01 | API  | DEBUG : GET /users/42"
profileLog.warn("Avatar load failed"); // silent — not in enabledExtensions

// Runtime toggling
log.disable("AUTH");
authLog.info("This is suppressed");

log.enable("AUTH");
authLog.info("Logging restored");

console.log(log.getExtensions()); // ["AUTH", "API", "PROFILE"]
```
```

--------------------------------

### logger.createLogger

Source: https://context7.com/mowispace/react-native-logs/llms.txt

The primary factory function to create a logger instance. It merges provided configuration with defaults and returns a typed logger. Calling it without arguments creates a basic console logger.

```APIDOC
## logger.createLogger(config?)

### Description
The primary factory function. Merges the provided configuration with sensible defaults and returns a fully typed logger instance whose methods are named after the configured levels. All parameters are optional; calling it with no arguments produces a console logger with `debug`, `info`, `warn`, and `error` levels.

### Parameters
#### Configuration Options
- **levels** (object) - Optional - Defines custom log levels with numeric severities.
- **severity** (string) - Optional - The minimum severity level to display (e.g., "debug", "info").
- **transport** (function) - Optional - The transport function to use for logging (e.g., `consoleTransport`).
- **transportOptions** (object) - Optional - Options specific to the chosen transport.
- **async** (boolean) - Optional - If true, defers log execution using `requestIdleCallback` or `setTimeout`.
- **dateFormat** (string | function) - Optional - Specifies the date format (e.g., "iso", "time", "local", "utc") or a custom formatting function.
- **printLevel** (boolean) - Optional - If true, prints the log level.
- **printDate** (boolean) - Optional - If true, prints the log date.
- **fixedExtLvlLength** (boolean) - Optional - If true, pads level/extension names for alignment.
- **enabled** (boolean) - Optional - If true, the logger is enabled.

### Example
```typescript
import { logger, consoleTransport } from "react-native-logs";

const log = logger.createLogger({
  levels: {
    trace: 0,
    debug: 1,
    info: 2,
    warn: 3,
    error: 4,
  },
  severity: "debug",
  transport: consoleTransport,
  transportOptions: {
    colors: {
      trace: "grey",
      debug: "cyan",
      info: "blueBright",
      warn: "yellowBright",
      error: "redBright",
    },
  },
  async: true,
  dateFormat: "iso",
  printLevel: true,
  printDate: true,
  fixedExtLvlLength: true,
  enabled: true,
});

log.trace("Starting up");
log.debug("Loaded config", { endpoint: "https://api.example.com" });
log.info("User authenticated", { userId: 42 });
log.warn("Retry attempt", { attempt: 2 });
log.error("Request failed", new Error("Network timeout"));
```
```

--------------------------------

### Log Multiple Arguments

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Concatenate multiple arguments when logging. This is useful for logging objects or additional context alongside a message.

```javascript
var errorObject = {
  status: 404,
  message: "Undefined Error",
};
log.error("New error occured", errorObject);

```

--------------------------------

### Configure File Async Transport with RNFS

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Utilize the `fileAsyncTransport` with `react-native-fs` to save logs to a file. Ensure `RNFS` is imported and provided as the `FS` option.

```javascript
import { logger, fileAsyncTransport } from "react-native-logs";
import RNFS from "react-native-fs";

var log = logger.createLogger({
  transport: fileAsyncTransport,
  transportOptions: {
    FS: RNFS,
    fileName: `log.txt`,
  },
});

log.debug("Debug message");

```

--------------------------------

### Dynamically Enable/Disable Loggers and Extensions

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Control logger and extension visibility at runtime using 'disable' and 'enable' methods. Calling 'disable()' without parameters disables the entire logger.

```javascript
import { logger, consoleTransport } from "react-native-logs";

var log = logger.createLogger({
  transport: consoleTransport,
  enabledExtensions: ["ROOT", "HOME"],
});

var rootLog = log.extend("ROOT");
var homeLog = log.extend("HOME");

log.info("print this"); // this will print "<time> | ROOT | INFO | print this"
homeLog.info("print this"); // extension is enabled

log.disable("HOME");

homeLog.info("not print this"); // extension is not enabled
rootLog.info("print this"); // extension is enabled

log.disable();

homeLog.info("not print this"); // logger is not enabled
rootLog.info("not print this"); // logger is not enabled
log.info("not print this"); // logger is not enabled
```

--------------------------------

### log.patchConsole() / getOriginalConsole()

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Monkey-patches the global `console` object to route all `console.*` calls through the react-native-logs pipeline. The original console object is preserved and can be retrieved.

```APIDOC
## `log.patchConsole() / getOriginalConsole()` — Intercept global console

Monkey-patches the global `console` object so that all `console.*` calls are routed through the react-native-logs pipeline. This is useful when migrating an existing codebase that uses `console.log` directly. The original console is preserved and retrievable.

```typescript
import { logger, consoleTransport } from "react-native-logs";

const log = logger.createLogger({
  levels: { debug: 0, log: 1, info: 2, warn: 3, error: 4 },
  severity: "log",  // console.debug calls will be suppressed
  transport: consoleTransport,
  transportOptions: { colors: { warn: "yellow", error: "red" } },
});

console.log("Uses native console");   // native output

log.patchConsole();

console.log("Routed through logger"); // now filtered, formatted, colorized
console.warn("Also routed");
console.debug("Suppressed by severity = log");

// Escape hatch — bypass the patched console:
const orig = log.getOriginalConsole();
orig.log("Direct native output, bypasses logger");
```
```

--------------------------------

### setSeverity

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Sets the minimum severity level for logs to be displayed, overriding the initial configuration.

```APIDOC
## setSeverity

### Description
Set the severity level for logs. Only logs with a severity equal to or higher than the specified level will be printed. This method overwrites any `config.severity` option set during logger creation.

### Method
`log.setSeverity(level: string)`

### Parameters
- `level` (string): The minimum severity level to display (e.g., "info", "warn", "error").

### Request Example
```javascript
var log = logger.createLogger();

log.setSeverity("info");
log.debug("This log will not be printed");
log.info("This log will be printed correctly");
log.error("This log will be printed correctly");
```
```

--------------------------------

### File System Transport with react-native-logs

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Appends log messages to a file using react-native-fs or expo-file-system. Use the `{date-today}` token in `fileName` to create a new file each day. The `FS` option is mandatory.

```typescript
import { logger, fileAsyncTransport } from "react-native-logs";
import RNFS from "react-native-fs";
// Expo legacy:  import * as FileSystem from "expo-file-system";
// Expo next:    import * as FileSystem from "expo-file-system/next";

const log = logger.createLogger({
  severity: "warn",   // Only warn and error written to disk
  transport: fileAsyncTransport,
  transportOptions: {
    FS: RNFS,         // or FileSystem for Expo
    fileName: "app_logs_{date-today}",  // → "app_logs_15-1-2024"
    fileNameDateType: "iso",            // "eu" DD-MM-YYYY | "us" MM-DD-YYYY | "iso" YYYY-MM-DD
    filePath: RNFS.DocumentDirectoryPath + "/logs", // optional custom path
  },
});

log.warn("Low memory warning");  // Appended to file
log.error("Crash prevented", { screen: "HomeScreen", userId: 7 });
// File contents:
// "10:30:15 | WARN  : Low memory warning\n"
// "10:30:16 | ERROR : Crash prevented \n{ \"screen\": \"HomeScreen\", ... }\n"
```

--------------------------------

### Namespaced Loggers with `log.extend()`

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Create child loggers that tag messages with a namespace. Extensions can be enabled/disabled via configuration or runtime methods. Ensure the namespace is listed in `enabledExtensions` to see output.

```typescript
import { logger, consoleTransport } from "react-native-logs";

const log = logger.createLogger({
  transport: consoleTransport,
  enabledExtensions: ["AUTH", "API"],   // PROFILE is created but silent
  transportOptions: {
    extensionColors: { AUTH: "magenta", API: "cyan" },
  },
});

const authLog    = log.extend("AUTH");
const apiLog     = log.extend("API");
const profileLog = log.extend("PROFILE");

authLog.info("Login successful");      // prints: "10:00:01 | AUTH | INFO : Login successful"
apiLog.debug("GET /users/42");         // prints: "10:00:01 | API  | DEBUG : GET /users/42"
profileLog.warn("Avatar load failed"); // silent — not in enabledExtensions

// Runtime toggling
log.disable("AUTH");
authLog.info("This is suppressed");

log.enable("AUTH");
authLog.info("Logging restored");

console.log(log.getExtensions()); // ["AUTH", "API", "PROFILE"]
```

--------------------------------

### patchConsole

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Overwrites the default console methods to use the react-native-logs logger, allowing centralized log management.

```APIDOC
## patchConsole

### Description
(Experimental) Overwrites the default `console` object with the `react-native-logs` logger. This allows you to manage all console logs (e.g., `console.log`, `console.error`) through your logger's configuration, transports, and severity levels. Be cautious as this can have unintended side effects.

### Method
`log.patchConsole()`

### Configuration Options
- `levels`: Maps log levels to specific console methods.
- `severity`: Sets the minimum severity level for logs.
- `printLevel`: Whether to print the log level.
- `printDate`: Whether to print the log date.

### Request Example
```javascript
import { logger, consoleTransport } from "react-native-logs";

const config = {
  levels: {
    debug: 0,
    log: 1,
    warn: 2,
    error: 3,
  },
  severity: "log",
  printLevel: true,
  printDate: true,
};

var log = logger.createLogger(config);

// This call uses the default console
console.log("This method uses default console");

log.patchConsole();

// All subsequent console calls will use your react-native-logs logger
console.log("This method uses your logger");
console.warn("This method uses your logger too");
console.debug("this message will not be shown"); // Not shown because severity is 'log'
```
```

--------------------------------

### Map Log Levels to Native Console Methods

Source: https://context7.com/mowispace/react-native-logs/llms.txt

The `mapConsoleTransport` routes log messages to specific native `console` methods (e.g., `console.log`, `console.error`). This preserves DevTools grouping and filtering capabilities. Define the mapping in `transportOptions.mapLevels`.

```typescript
import { logger, mapConsoleTransport } from "react-native-logs";

const log = logger.createLogger({
  levels: { debug: 0, info: 1, warn: 2, err: 3 },
  transport: mapConsoleTransport,
  transportOptions: {
    mapLevels: {
      debug: "log",    // console.log(...)
      info:  "info",   // console.info(...)
      warn:  "warn",   // console.warn(...)
      err:   "error",  // console.error(...)
    },
  },
});

log.debug("Initializing store");  // → console.log
log.info("Route changed");        // → console.info
log.warn("Deprecated API used");  // → console.warn
log.err("Unhandled exception");   // → console.error
```

--------------------------------

### log.setSeverity / getSeverity

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Dynamically change the minimum log level at runtime without recreating the logger. This is useful for toggling verbose logging during debugging or A/B testing log levels in production.

```APIDOC
## `log.setSeverity / getSeverity` — Dynamic severity control

Changes the minimum log level at runtime without recreating the logger. Useful for toggling verbose logging during debugging sessions or A/B testing log levels in production.

```typescript
import { logger } from "react-native-logs";

const log = logger.createLogger(); // default severity: "debug"

log.debug("Visible at startup");

log.setSeverity("warn");
log.debug("Hidden — below new severity");
log.info("Also hidden");
log.warn("Visible — at or above severity");
log.error("Visible");

console.log(log.getSeverity()); // "warn"

log.setSeverity("debug"); // Restore verbose logging
```
```

--------------------------------

### Dynamic Severity Control with `setSeverity`

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Change the minimum log level at runtime without recreating the logger. This is useful for toggling verbose logging during debugging or A/B testing log levels in production. Use `getSeverity` to retrieve the current level.

```typescript
import { logger } from "react-native-logs";

const log = logger.createLogger(); // default severity: "debug"

log.debug("Visible at startup");

log.setSeverity("warn");
log.debug("Hidden — below new severity");
log.info("Also hidden");
log.warn("Visible — at or above severity");
log.error("Visible");

console.log(log.getSeverity()); // "warn"

log.setSeverity("debug"); // Restore verbose logging
```

--------------------------------

### Configure Sentry Transport

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Integrate with Sentry to send logs. Allows specifying which log levels are treated as errors, with others acting as breadcrumbs.

```javascript
import { logger, sentryTransport } from "react-native-logs";
import * as Sentry from "@sentry/react-native";

/*
 * Configure sentry
 */

var log = logger.createLogger({
  severity: "debug",
  transport: sentryTransport,
  transportOptions: {
    SENTRY: Sentry,
    errorLevels: "error",
  },
});

log.warn("Send this log to Sentry as breadcumb");
log.error("Send this log to Sentry as error");
```

--------------------------------

### getOriginalConsole

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Retrieves the original console object if it was previously overwritten by `patchConsole`.

```APIDOC
## getOriginalConsole

### Description
Retrieves the original `console` object that was in place before `patchConsole` was called.

### Method
`log.getOriginalConsole()`

### Returns
- `Console`: The original console object.

### Request Example
```javascript
var originalConsole = log.getOriginalConsole();
originalConsole.log("This will use the standard console.log");
```
```

--------------------------------

### Multiple transports

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Send log messages to multiple destinations simultaneously by passing an array of transport functions to the `transport` option. All transports share the same `transportOptions` object.

```APIDOC
## Multiple transports — Fan-out to several destinations

Pass an array of transport functions to `transport` to send every log message to multiple destinations simultaneously. All transports share the single `transportOptions` object.

```typescript
import {
  logger,
  consoleTransport,
  fileAsyncTransport,
  sentryTransport,
  transportFunctionType,
} from "react-native-logs";
import RNFS from "react-native-fs";
import * as Sentry from "@sentry/react-native";

const analyticsTransport: transportFunctionType<{}> = (props) => {
  if (props.level.severity >= 2) {
    myAnalytics.track("log_event", { level: props.level.text, msg: props.msg });
  }
};

const log = logger.createLogger({
  severity: __DEV__ ? "debug" : "warn",
  transport: [consoleTransport, fileAsyncTransport, sentryTransport, analyticsTransport],
  transportOptions: {
    colors:      { warn: "yellowBright", error: "redBright" },
    FS:          RNFS,
    fileName:    "app_{date-today}.log",
    SENTRY:      Sentry,
    errorLevels: "error",
  },
});

log.debug("Render cycle");   // dev only: console
log.warn("Token expiring");  // console + file + sentry breadcrumb + analytics
log.error("Auth failed");    // console + file + sentry exception + analytics
```
```

--------------------------------

### mapConsoleTransport

Source: https://context7.com/mowispace/react-native-logs/llms.txt

A transport that maps log levels to specific native `console` methods (e.g., `console.log`, `console.info`). This helps preserve browser/React Native DevTools grouping and filtering by console method type.

```APIDOC
## mapConsoleTransport

### Description
Routes each log level to a specific native `console` method (`console.log`, `console.info`, `console.warn`, `console.error`). This preserves browser/React Native DevTools grouping and filtering by console method type. If `mapLevels` is omitted the transport tries to call `console[levelName]` directly.

### Parameters
#### Transport Options
- **mapLevels** (object) - Optional - An object mapping log level names to native console method names (e.g., `{ debug: "log", info: "info" }`).

### Example
```typescript
import { logger, mapConsoleTransport } from "react-native-logs";

const log = logger.createLogger({
  levels: { debug: 0, info: 1, warn: 2, err: 3 },
  transport: mapConsoleTransport,
  transportOptions: {
    mapLevels: {
      debug: "log",
      info:  "info",
      warn:  "warn",
      err:   "error",
    },
  },
});

log.debug("Initializing store");
log.info("Route changed");
log.warn("Deprecated API used");
log.err("Unhandled exception");
```
```

--------------------------------

### Configure Logger with Custom Levels

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Define custom log levels with specific severity values. This allows for more granular control over log message importance. Import 'logger' from 'react-native-logs'.

```javascript
import { logger } from "react-native-logs";

var log = logger.createLogger({
  levels: {
    trace: 0,
    info: 1,
    silly: 2,
    error: 3,
    mad: 4,
  },
});

log.silly("Silly message");
```

--------------------------------

### Fan-out to Multiple Transports

Source: https://context7.com/mowispace/react-native-logs/llms.txt

Send log messages to multiple destinations simultaneously by passing an array of transport functions to the logger configuration. All transports share the same transport options.

```typescript
import {
  logger,
  consoleTransport,
  fileAsyncTransport,
  sentryTransport,
  transportFunctionType,
} from "react-native-logs";
import RNFS from "react-native-fs";
import * as Sentry from "@sentry/react-native";

const analyticsTransport: transportFunctionType<{}> = (props) => {
  if (props.level.severity >= 2) {
    myAnalytics.track("log_event", { level: props.level.text, msg: props.msg });
  }
};

const log = logger.createLogger({
  severity: __DEV__ ? "debug" : "warn",
  transport: [consoleTransport, fileAsyncTransport, sentryTransport, analyticsTransport],
  transportOptions: {
    colors:      { warn: "yellowBright", error: "redBright" },
    FS:          RNFS,
    fileName:    "app_{date-today}.log",
    SENTRY:      Sentry,
    errorLevels: "error",
  },
});

log.debug("Render cycle");   // dev only: console
log.warn("Token expiring");  // console + file + sentry breadcrumb + analytics
log.error("Auth failed");    // console + file + sentry exception + analytics
```

--------------------------------

### getSeverity

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Retrieves the current severity level that is set for the logger.

```APIDOC
## getSeverity

### Description
Get the current severity level that is set for the logger.

### Method
`log.getSeverity()`

### Returns
- `string`: The current severity level (e.g., "debug", "info", "warn", "error").

### Request Example
```javascript
var log = logger.createLogger();

var defaultSeverity = log.getSeverity(); // Default severity is usually 'debug'
log.setSeverity("info");
var severity = log.getSeverity(); // severity = "info"
log.setSeverity("error");
var newSeverity = log.getSeverity(); // newSeverity = "error"
```
```

--------------------------------

### consoleTransport

Source: https://context7.com/mowispace/react-native-logs/llms.txt

The default transport that prints formatted log messages to the console. It supports ANSI color codes for levels and extension labels, and allows redirection of output via a custom `consoleFunc`.

```APIDOC
## consoleTransport

### Description
The default transport. Prints formatted log messages via `console.log`, supporting ANSI color codes for both level text and extension labels. Pass a custom `consoleFunc` to redirect output to any sink that accepts a string.

### Parameters
#### Transport Options
- **colors** (object) - Optional - Defines ANSI color codes for log levels.
- **extensionColors** (object) - Optional - Defines ANSI color codes for logger extension labels.
- **consoleFunc** (function) - Optional - A custom function to handle log output, replacing `console.log`.

### Example
```typescript
import { logger, consoleTransport } from "react-native-logs";

const log = logger.createLogger({
  transport: consoleTransport,
  transportOptions: {
    colors: {
      debug: "cyan",
      info: "blueBright",
      warn: "yellowBright",
      error: "redBright",
    },
    extensionColors: {
      AUTH: "magentaBright",
      API:  "greenBright",
    },
    consoleFunc: (msg: string) => myCustomSink.write(msg),
  },
});

const authLog = log.extend("AUTH");
const apiLog  = log.extend("API");

authLog.info("Token refreshed");
apiLog.error("404 Not Found");
log.warn("Disk space low");
```
```

--------------------------------

### Create Custom Transport in TypeScript

Source: https://github.com/mowispace/react-native-logs/blob/master/README.md

Define a custom transport function to handle log messages. This function receives log properties and can be configured with custom options via `transportOptions`.

```typescript
import { logger, transportFunctionType } from "react-native-logs";

const customTransport: transportFunctionType<{ myCustomOption: string }> = (
  props
) => {
  // Do here whatever you want with the log message
  // You can use any options setted in config.transportOptions
  // Eg. a console log: console.log(props.level.text, props.msg)
};

var log = logger.createLogger({
  transport: customTransport,
  transportOptions: {
    myCustomOption: "option",
  },
});

log.debug("Debug message");

```