rLog

https://rlog.daymxn.com/docs
Admin
rLog is a context-based server-side logging framework for ROBLOX that provides structured logging,...
Tokens:25,423
Snippets:321
Trust Score:5.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### View Console Output

Source: https://rlog.daymxn.com/docs/basics/log-context

Example of the structured log output generated by the rLog context.

```text
[INFO]: Actions -> Buying pet  
{  
  data: { player: "Player1", pet: "18219" },  
  correlation_id: "QQLRSFsPfoTfgD7b"  
}  
  
[INFO]: Actions -> Pet bought  
{ correlation_id: "QQLRSFsPfoTfgD7b" }  
```

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

### Install rLog with pnpm

Source: https://rlog.daymxn.com/docs/quick-start

Install the rLog package using pnpm. This is an alternative package manager for installing rLog.

```bash
pnpm add @rbxts/rlog  
```

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

### Suspended Context Console Output

Source: https://rlog.daymxn.com/docs/basics/log-context

Example output showing logs appearing in correct chronological order.

```text
[DEBUG]: Actions -> Buying pet  
{  
  data: { player: "Player1", pet: "18219" },  
  correlation_id: "QQLRSFsPfoTfgD7b"  
}  
  
[ERROR]: Saves -> Failed to load player save  
{  
  data: { err: "Roblox datastore API is down" },  
  correlation_id: "QQLRSFsPfoTfgD7b"  
}  
```

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

### Log Output Format

Source: https://rlog.daymxn.com/docs/basics/log-levels

Example of how a log entry appears in the console with its severity level.

```text
[WARN]: There was an issue!
```

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

### Install rLog with yarn

Source: https://rlog.daymxn.com/docs/quick-start

Install the rLog package using yarn. This is another common package manager for installing rLog.

```bash
yarn add @rbxts/rlog  
```

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

### Install rLog with npm

Source: https://rlog.daymxn.com/docs/quick-start

Install the rLog package using npm. This is the first step to integrating rLog into your ROBLOX project.

```bash
npm install @rbxts/rlog  
```

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

### Configure and use suspendContext

Source: https://rlog.daymxn.com/docs/api/rlog.rlogconfig.suspendcontext

Example showing how to enable suspendContext within a log context to buffer messages.

```typescript
const config = { minLogLevel: LogLevel.DEBUG, suspendContext: true }  
  
withLogContext(config, (context) => {  
  const logger = context.use();  
  
  logger.i("Hello world!");  
  logger.w("Oh no!");  
  logger.i("Goodbye world!");  
});  
// > [INFO]: Hello world!  
// > { correlation_id: "QQLRSFsPfoTfgD7b" }  
//  
// > [WARNING]: Oh no!  
// > { correlation_id: "QQLRSFsPfoTfgD7b" }  
//  
// > [INFO]: Goodbye world!  
// > { correlation_id: "QQLRSFsPfoTfgD7b" }
```

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

### Console Output with Context Bypass

Source: https://rlog.daymxn.com/docs/fast-breakdown

Example console output showing how DEBUG and INFO logs are included due to context bypass when a WARNING is present.

```log
[DEBUG]: Some extra data  
{
  correlation_id: "BNPmmqDsnpLdWiPF"
}

[INFO]: Doing stuff  
{
  correlation_id: "BNPmmqDsnpLdWiPF"
}

[WARNING]: Something happened  
{
  correlation_id: "BNPmmqDsnpLdWiPF"
}

[INFO]: Done  
{
  correlation_id: "BNPmmqDsnpLdWiPF"
}

```

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

### Demonstrate Sink Order and Consumption

Source: https://rlog.daymxn.com/docs/basics/sinks

Illustrates how sinks are executed in the order they are provided. If an earlier sink consumes a log entry (returns true), subsequent sinks in the list will not be called. This example shows a first sink consuming the log, preventing an error from being thrown by the second sink.

```typescript
import { rLog } from "@rbxts/rlog";

const logger = new rLog({
  sinks: [
    (entry) => {
      return true;
    },
    (entry) => {
      error("Messages should not log to the console");
    },
  ],
});

logger.i("Hello world!");
```

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

### Context Bypass Console Output

Source: https://rlog.daymxn.com/docs/basics/log-context

Example output showing debug logs captured despite a higher minLogLevel.

```text
  
[ERROR]: Saves -> Failed to load player save  
{  
  data: { err: "Roblox datastore API is down" },  
  correlation_id: "QQLRSFsPfoTfgD7b"  
}  
  
[DEBUG]: Actions -> Buying pet  
{  
  data: { player: "Player1", pet: "18219" },  
  correlation_id: "QQLRSFsPfoTfgD7b"  
}  
```

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

### Log Context Tracker Example

Source: https://rlog.daymxn.com/docs/faq

Illustrates a TypeScript approach to tracking LogContext using a record mapping coroutines to their contexts. This method has limitations with asynchronous operations.

```typescript
const contextTracker: Record<coroutine, LogContext> = [];  
```

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

### Log Output with Timestamp and Correlation ID

Source: https://rlog.daymxn.com/docs/basics/log-entries

Example of log output format, including the timestamp in epoch milliseconds and a correlation ID for tracking across different log instances.

```text
[INFO]: Actions -> Hello world! 
{
  timestamp: 1723757975945,
  correlation_id: "Xzm9InKevNRjvqqo"
}
```

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

### Define Log Context Action

Source: https://rlog.daymxn.com/docs/basics/log-context

Example of a log-enabled action function using LogContext.

```typescript
import { LogContext, LogConfig } from "@rbxts/rlog";  
import { save } from "./save";  
  
const config: LogConfig = { tag: "Actions" };  
  
export async function buyPet(context: LogContext, player: PlayerId, pet: PetId) {  
  const logger = context.use(config);  
  
  logger.d("Buying pet", { player: player, pet: pet });  
  
  const playerSave = await save.get(context, player);  
  
  // ...  
  
  logger.d("Pet bought");  
}  
```

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

### Custom Log Output Method

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Example of a custom output method that simply prints the formatted messages to the console. This bypasses the default warning/print logic.

```typescript
import { LogEntry, OutputMethodCallback } from "@rbxts/rlog";

export const customOutputMethod: OutputMethodCallback = (entry, messages) => {
  print(...messages);
};

```

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

### Default Format Method Implementation

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Provides an example of what the default format method in robloxConsoleSink might look like. It formats log level, tag, message, and encoded data.

```typescript
function defaultFormatEntry(entry: LogEntry) {
  const tag = entry.config.tag !== undefined ? `${entry.config.tag} -> ` : "";
  
  const data = {
    correlation_id: entry.context?.correlation_id,
    timestamp: entry.timestamp,
    data: Object.isEmpty(entry.encoded_data) ? undefined : entry.encoded_data,
  };
  
  return $tuple(`[${LogLevel[entry.level]}]:`, `${tag}${entry.message}\n${HttpService.JSONEncode(data)}`);
}

```

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

### Custom Log Formatting Method

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Example of a custom format method that returns the log entry's message and encoded data. This leverages Roblox console's ability to display tables.

```typescript
import { LogEntry, FormatMethodCallback } from "@rbxts/rlog";  
  
export const customFormatMethod: FormatMethodCallback = (entry) => {
  return $tuple(entry.message, entry.encoded_data);
};

```

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

### Apply Custom Output Method to rLog

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Configures rLog to use a custom output method for the robloxConsoleSink. This example logs a simple informational message.

```typescript
import { rLog, robloxConsoleSink } from "@rbxts/rlog";
import { customOutputMethod } from "./custom-output";

rLog.UpdateDefaultConfig({
  sinks: [
    robloxConsoleSink({
      outputMethod: customOutputMethod,
    }),
  ],
});

const logger = new rLog();

logger.i("Hello world!");

```

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

### Using withLogContext in a Remote Event

Source: https://rlog.daymxn.com/docs/api/rlog.withlogcontext_1

Example of wrapping a remote event connection callback with withLogContext to manage context lifecycle automatically.

```typescript
remotes.buyPet.connect((player: Player, pet: PetId) => {  
  // automatically starts and stops the context  
  withLogContext((context) => {  
    buyPet(context, player.UserId, pet);  
  });  
});
```

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

### Define a Loggable Action

Source: https://rlog.daymxn.com/docs/basics/log-context

A basic function setup using LogContext to log events within a specific tag configuration.

```typescript
import { LogContext, LogConfig } from "@rbxts/rlog";  
  
const config: LogConfig = { tag: "Actions" };  
  
export function buyPet(context: LogContext, player: PlayerId, pet: PetId) {  
  const logger = context.use(config);  
  
  logger.i("Buying pet", { player: player, pet: pet });  
  
  // ..  
  
  logger.i("Pet bought");  
}  
```

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

### Example Log Output with Correlation ID

Source: https://rlog.daymxn.com/docs/fast-breakdown

This console output demonstrates how logs are tagged with a correlation ID. All log messages related to a single `withLogContext` invocation share the same `correlation_id`, allowing for easy tracking of a specific process flow.

```log
[INFO]: PlayerActions -> Giving player money  
{
  data: { player: "Player1", money: 100 },
  correlation_id: "ZnT961Kwlav6JFii"
}

[INFO]: Datastore -> Adding money to player save  
{
  correlation_id: "ZnT961Kwlav6JFii"
}

[INFO]: Datastore -> Money added  
{
  correlation_id: "ZnT961Kwlav6JFii"
}

[INFO]: PlayerActions -> Money given to player  
{
  correlation_id: "ZnT961Kwlav6JFii"
}

```

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

### Implement Automatic Scoping

Source: https://rlog.daymxn.com/docs/basics/log-context

Use withLogContext to automatically start and stop the log context during remote event handling.

```typescript
import { withLogContext } from "@rbxts/rlog";  
import { remotes } from "./remotes";  
import { buyPet } from "./actions/pets";  
  
remotes.buyPet.connect((player: Player, pet: PetId) => {  
  // automatically starts and stops the context  
  withLogContext((context) => {  
    buyPet(context, player.UserId, pet);  
  });  
});  
```

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

### Network Remote for Giving Money

Source: https://rlog.daymxn.com/docs/fast-breakdown

Connects to a network remote to trigger the GiveMoney function, starting and stopping a LogContext.

```typescript
import { LogContext } from "@rbxts/rlog";  
import { GiveMoney } from "./player-actions";  
import { remotes } from "./remotes";  
  
remotes.giveMoney.connect((player: Player, money: number) => {  
	const context = LogContext.start();  

	GiveMoney(context, player, money);  

	context.stop();  
});

```

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

### Apply Custom Formatter to rLog

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Configures rLog to use a custom format method for the robloxConsoleSink. This example logs a message with associated data.

```typescript
import { rLog, robloxConsoleSink } from "@rbxts/rlog";
import { customFormatMethod } from "./custom-formatter";

rLog.UpdateDefaultConfig({
  sinks: [
    robloxConsoleSink({
      formatMethod: customFormatMethod,
    }),
  ],
});

const logger = new rLog();

logger.i("Hello world!", { time: DateTime.now() });

```

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

### Define Custom Log Formatting Method

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Create a custom format method to control the shape of log data output to the console. This example includes context data like correlation_id if available.

```typescript
import { LogEntry, FormatMethodCallback } from "@rbxts/rlog";

export const customFormatMethod: FormatMethodCallback = (entry) => {
  if (entry.context) {
    return $tuple(entry.message, {
      correlation_id: entry.context.correlation_id,
    });
  } else {
    return $tuple(entry.message);
  }
};

```

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

### Network Handler for Giving Money

Source: https://rlog.daymxn.com/docs/basics/log-context

This snippet sets up a network remote connection to trigger the GiveMoney function. It starts a new log context for the request, calls GiveMoney, and then stops the context, ensuring all logs within this flow share a correlation ID.

```typescript
import { LogContext } from "@rbxts/rlog";  
import { GiveMoney } from "./player-actions";  
import { remotes } from "./remotes";  
  
remotes.giveMoney.connect((player: Player, money: number) => {  
  const context = LogContext.start();  
  
  GiveMoney(context, player, money);  
  
  context.stop();  
});

```

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

### Console Log Output with Correlation ID

Source: https://rlog.daymxn.com/docs/basics/log-context

This example shows the expected console output when using rLog's context. Notice how each log entry within the same flow shares a unique 'correlation_id', allowing for easy filtering and debugging.

```log
[INFO]: PlayerActions -> Giving player money  
{
  data: { player: "Player1", money: 100 },
  correlation_id: "ZnT961Kwlav6JFii"
}

[INFO]: Datastore -> Adding money to player save
{
  correlation_id: "ZnT961Kwlav6JFii"
}

[INFO]: Datastore -> Money added
{
  correlation_id: "ZnT961Kwlav6JFii"
}

[INFO]: PlayerActions -> Money given to player
{
  correlation_id: "ZnT961Kwlav6JFii"
}

```

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

### Create rLog Instances

Source: https://rlog.daymxn.com/docs/fast-breakdown

Demonstrates initializing the default logger and creating custom instances.

```typescript
import { rLog, rLogger } from "@rbxts/rlog";  
  
// use the default instance  
rLogger.info("Hello world!");  
  
// create your own instance  
const logger = new rLog();  
```

```typescript
import { RLog, rLog, rlog } from "@rbxts/rlog";  
  
const logger = new rLog();  
const logger = new rlog();  
const logger = new RLog();  
```

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

### Basic Logging with rLog

Source: https://rlog.daymxn.com/docs/basics/log-entries

Demonstrates how to initialize the rLog logger and send an informational message. Ensure rLog is imported before use.

```typescript
import { rLog } from "@rbxts/rlog";

const logger = new rLog();

logger.info("Hello world!");
```

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

### Configure Instance Settings

Source: https://rlog.daymxn.com/docs/fast-breakdown

Apply settings via the constructor or helper methods. Note that methods return new instances due to immutability.

```typescript
import { rLog, LogLevel } from "@rbxts/rlog";  
  
const logger = new rLog({ minLogLevel: LogLevel.DEBUG });  
```

```typescript
const logger = new rLog()  
	.withConfig(myConfig)  
	.withMinLogLevel(LogLevel.DEBUG)  
	.withTag("Main")  
	.withContext(customContext);  
```

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

### Initialize rLog with a Custom Sink

Source: https://rlog.daymxn.com/docs/basics/sinks

Demonstrates how to initialize an rLog instance with a custom sink, such as the 'removeAdminCallsSink'. Sinks are configured via the 'sinks' property in the rLog configuration.

```typescript
import { rLog } from "@rbxts/rlog";
import { removeAdminCallsSink } from "./remove-admin-calls-sink";

const logger = new rLog({ sinks: [removeAdminCallsSink] });
```

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

### Configure Global Settings

Source: https://rlog.daymxn.com/docs/fast-breakdown

Manage default configuration settings that apply to all subsequently created instances.

```typescript
import { rLog, LogLevel } from "@rbxts/rlog";  
  
const config = {  
	minLogLevel: LogLevel.DEBUG,  
};  
  
// Sets the default config, replacing any present values  
rLog.SetDefaultConfig(config);  
  
// Updates the default config, merging with the existing config  
rLog.UpdateDefaultConfig({ serialization: { encodeFunctions: true } });  
  
// Resets the default config to the original values  
rLog.ResetDefaultConfig();  
```

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

### Create an inherited LogContext with withConfig

Source: https://rlog.daymxn.com/docs/api/rlog.logcontext.withconfig

Demonstrates creating a secondary context that inherits the configuration of a main context while adding new settings.

```typescript
const mainContext = LogContext.start({ minLogLevel: LogLevel.DEBUG });  
  
// inherits the `minLogLevel`  
const secondaryContext = mainContext.withConfig({ contextBypass: true });
```

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

### Define Log Entry Type

Source: https://rlog.daymxn.com/docs/fast-breakdown

Defines the type for a log entry, used by enricher callbacks. No setup required.

```typescript
export type LogEntry = {  
	level: LogLevel;  
	message: string;  
	encoded_data: any;  
	tags: string[];  
};  

```

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

### Configure rLog with Custom Enrichers in TypeScript

Source: https://rlog.daymxn.com/docs/basics/enrichers

Demonstrates how to initialize rLog with a custom enricher using the `enrichers` configuration option. Ensure the enricher file is correctly imported.

```typescript
import { rLog } from "@rbxts/rlog";  
import { timestampEnricher } from "./timestamp-enricher";  
  
const logger = new rLog({ enrichers: [timestampEnricher] });  

```

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

### Info Logging in rLog

Source: https://rlog.daymxn.com/docs/basics/log-levels

Demonstrates using the info level and its shorthand alias 'i' for tracking application control flow.

```typescript
import { rLog } from "@rbxts/rlog";
import { sendPayment } from "./payment";

const logger = new rLog();

logger.verbose("Application started");

function processOrder(orderId: string, userId: string) {
	logger.i("Processing order");

	logger.v("Fetching details for order", { order: orderId, user: userId });

	const orderDetails = { items: ["item1", "item2"], total: 100 };

	logger.d(`Retrieved order details`, { details: orderDetails });

	logger.i("Order complete");
}

processOrder("12345", "user789");
```

```text
[VERBOSE]: Application started

[INFO]: Processing order

[VERBOSE]: Fetching details for order
{ data: { order: "12345", "user789" } }

[DEBUG]: Retrieved order details
{ data: { details: { items: ["item1", "item2"], total: 100 } } }

[INFO]: Order complete
```

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

### Add Timestamp Enricher

Source: https://rlog.daymxn.com/docs/fast-breakdown

An example of an enricher function that adds a timestamp to the log entry's encoded data. The enricher is passed to the rLog constructor.

```typescript
import { rLog } from "@rbxts/rlog";  
  
function addTimestamp(entry: LogEntry): LogEntry {  
	entry.encoded_data["timestamp"] = DateTime.now();  
  
	return entry;  
}  
  
const logger = new rLog({ enrichers: [addTimestamp] });  

```

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

### LogContext.withConfig() Method

Source: https://rlog.daymxn.com/docs/api/rlog.logcontext.withconfig

This method creates a new LogContext instance that inherits the current context's properties and merges them with a provided configuration object. It's useful for creating specialized log contexts without affecting the original.

```APIDOC
## LogContext.withConfig()

### Description
Creates a new LogContext instance that inherits this context and merges it with a provided configuration.

### Method
`withConfig`

### Endpoint
N/A (Instance method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### Instance Parameters
- **config** (PartialRLogConfig) - Required - The configuration object to merge with the current context.

### Request Example
```typescript
const mainContext = LogContext.start({ minLogLevel: LogLevel.DEBUG });
const secondaryContext = mainContext.withConfig({ contextBypass: true });
```

### Response
#### Success Response (LogContext)
- Returns a new `LogContext` instance with the merged configuration.

#### Response Example
```typescript 
// Assuming LogContext is a class or object
// The actual returned object would be an instance of LogContext
{
  // ... properties of the new LogContext instance ...
}
```

### Exceptions
- If the context is dead (i.e., if `stop` was called already).

### Remarks
The correlation id will remain the same, but the configuration will be merged with the provided config. This allows for creating slightly different versions of the same context.
```

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

### Initialize rLog Logger

Source: https://rlog.daymxn.com/docs/quick-start

Import and create a new instance of the rLog logger. This logger can then be used to log messages.

```typescript
import { rLog } from "@rbxts/rlog";  

// Initialize the logger  
const logger = new rLog();  
```

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

### Conditional Enricher Execution in TypeScript

Source: https://rlog.daymxn.com/docs/basics/enrichers

This example demonstrates how to conditionally apply an enricher based on the log level. The enricher only modifies entries with a level of WARNING or higher.

```typescript
import { LogEnricherCallback, LogEntry, LogLevel, rLog } from "@rbxts/rlog";  
  
export const timestampEnricher: LogEnricherCallback = (entry: LogEntry) => {  
	// just return the instance without changing anything  
	if (entry.Level < LogLevel.WARNING) return entry;  
	// ...  
};  

```

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

### Automatic Context Drilling - Before

Source: https://rlog.daymxn.com/docs/faq

Presents a scenario where logging occurs without explicit context passing, demonstrating the 'before' state for AST transformation.

```typescript
function SomeFunctionThatLogs() {
	rLogger.info("Hello world!");
}

function SomeFunction() {
	SomeFunctionThatLogs();
}

withLogContext(() => {
	SomeFunction();
});  
```

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

### Create a Timestamp Enricher in TypeScript

Source: https://rlog.daymxn.com/docs/basics/enrichers

This enricher adds a current timestamp to the log entry's encoded data. It serves as a basic example for creating custom enrichers.

```typescript
import { LogEnricherCallback, LogEntry } from "@rbxts/rlog";  
  
export const timestampEnricher: LogEnricherCallback = (entry: LogEntry) => {  
	entry.encoded_data["timestamp"] = DateTime.now();  
	return entry;  
};  

```

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

### @rbxts/rlog Overview

Source: https://rlog.daymxn.com/docs/api

Overview of the rlog logging framework package.

```APIDOC
## @rbxts/rlog

### Description
Context-based server-side logging framework for ROBLOX projects.

### Package Details
- **Name**: @rbxts/rlog
- **Purpose**: Provides structured logging capabilities for server-side ROBLOX scripts.
```

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

### Logging Warnings with rLog

Source: https://rlog.daymxn.com/docs/basics/log-levels

Demonstrates using various log levels including warnings within a process flow.

```typescript
import { rLog } from "@rbxts/rlog";  
import { sendPayment } from "./payment";  
  
const logger = new rLog();  
  
logger.verbose("Application started");  
  
function processOrder(orderId: string, userId: string) {  
	logger.i("Processing order");  
  
	logger.v("Fetching details for order", { order: orderId, user: userId });  
  
	const orderDetails = { items: ["item1", "item2"], total: 1 };  
  
	logger.d(`Retrieved order details`, { details: orderDetails });  
  
	if (orderDetails.total < 10) {  
		logger.w("Order has a suspiciously low total");  
	}  
  
	logger.v("Sending order for payment");  
  
	const paymentSuccessful = sendPayment(order, userId, orderDetails);  
  
	if (!paymentSuccessful) {  
		logger.w("Payment for order failed");  
	}  
  
	logger.i("Order complete");  
}  
  
processOrder("12345", "user789");
```

```text
[VERBOSE]: Application started  
  
[INFO]: Processing order  
  
[VERBOSE]: Fetching details for order  
{ data: { order: "12345", "user789" } }  
  
[DEBUG]: Retrieved order details  
{ data: { details: { items: ["item1", "item2"], total: 1 } } }  
  
[WARNING]: Order has a suspiciously low total  
  
[VERBOSE]: Sending order for payment  
  
[WARNING]: Payment for order failed  
  
[INFO]: Order complete
```

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

### RLog.withLogContext()

Source: https://rlog.daymxn.com/docs/api/rlog.rlog.withlogcontext

Returns a new RLog with the context set to the provided context.

```APIDOC
## RLog.withLogContext()

### Description
Returns a new RLog with the context set to the provided context.

### Method
N/A (This is a method of an object, not a standalone API endpoint)

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```typescript
// Assuming 'rlogInstance' is an existing RLog instance and 'newContext' is a LogContext object
const newRlogInstance = rlogInstance.withLogContext(newContext);
```

### Response
#### Success Response (N/A - returns an object)
- **RLog** (RLog) - The new RLog instance with the updated context.

#### Response Example
```json
// The returned value is an RLog object, not a JSON response.
// Example of a LogContext object:
{
  "key1": "value1",
  "key2": 123
}
```
```

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

### Import Global rLog Instance

Source: https://rlog.daymxn.com/docs/quick-start

Import the globally available rLog instance if you do not need to create a custom logger. This provides a convenient way to access the logger.

```typescript
import { rLogger } from "@rbxts/rlog";  
```

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

### Log Context Annotation - Before

Source: https://rlog.daymxn.com/docs/faq

Shows the usage of a hypothetical `@LogContext` annotation and `withLogContext` for managing log context before automatic transformation.

```typescript
@LogContext  
function SomeFunction() {
  const logger = context.use();  
  // ...  
}

withLogContext(() => {
  SomeFunction();
});  
```

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

### Network Handler with Log Context

Source: https://rlog.daymxn.com/docs/fast-breakdown

This code sets up a network remote that, when triggered, initiates a logging context and calls the GiveMoney function. It uses `withLogContext` to ensure a correlation ID is generated and passed.

```typescript
import { withLogContext } from "@rbxts/rlog";  
import { GiveMoney } from "./player-actions";  
import { remotes } from "./remotes";  
  
remotes.giveMoney.connect((player: Player, money: number) => {  
	withLogContext((context) => {  
		GiveMoney(context, player, money);  
	});  
});

```

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

### Configure rLog with Multiple Enrichers in TypeScript

Source: https://rlog.daymxn.com/docs/basics/enrichers

Shows how to apply multiple enrichers in a specific order using the `withEnrichers` method. The order determines the data flow between enrichers.

```typescript
import { rLog } from "@rbxts/rlog";  
import { timestampEnricher } from "./timestamp-enricher";  
import { transformTimestampEnricher } from "./transform-timestamp-enricher";  
  
const logger = new rLog().withEnrichers(timestampEnricher, transformTimestampEnricher);  
  
logger.i("Hello world!");  

```

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

### Default Output Method Implementation

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Shows the default output method for robloxConsoleSink, which uses 'warn' for WARNING level logs and above, and 'print' for others.

```typescript
const defaultOutputEntry: OutputMethodCallback = (entry, messages) => {
  if (entry.level >= LogLevel.WARNING) {
    warn(...messages);
  } else {
    print(...messages);
  }
};

```

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

### Configure Enricher Execution Order

Source: https://rlog.daymxn.com/docs/basics/default-instance

Demonstrates how instance-specific enrichers execute before default enrichers in a bottom-up fashion.

```typescript
import { rLog } from "@rbxts/rlog";  
  
rLog.UpdateDefaultConfig({  
  enrichers: [  
    (entry) => {  
      entry.message = `${entry.message}1`;  
      return entry;  
    },  
  ],  
});  
  
const logger = new rLog({  
  enrichers: [  
    (entry) => {  
      entry.message = `${entry.message}2`;  
      return entry;  
    },  
  ],  
});  
  
logger.i("Enrichers: ");  
```

```text
[INFO]: Enrichers: 21  
```

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

### Using withLogContext for Automatic Context Management

Source: https://rlog.daymxn.com/docs/fast-breakdown

Demonstrates using withLogContext to automatically manage the lifecycle of a LogContext, preventing memory leaks.

```typescript
import { withLogContext } from "@rbxts/rlog";  
import { GiveMoney } from "./player-actions";  
import { remotes } from "./remotes";  
  
remotes.giveMoney.connect((player: Player, money: number) => {  
	// automatically starts and stops the context  
	withLogContext((context) => {  
		GiveMoney(context, player, money);  
	});  
});

```

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

### RLogConstructorParameters.inheritDefault

Source: https://rlog.daymxn.com/docs/api/rlog.rlogconstructorparameters.inheritdefault

Documentation for the inheritDefault property within the RLogConstructorParameters interface.

```APIDOC
## RLogConstructorParameters.inheritDefault

### Description
Determines whether the logger instance should inherit default configuration settings.

### Signature
`inheritDefault?: boolean;`
```

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

### Add Money Function with Log Context

Source: https://rlog.daymxn.com/docs/basics/log-context

This function demonstrates how to use log context to add a logger with a specific configuration for datastore operations. It logs the action of adding money and confirms completion.

```typescript
import { rLog, LogContext } from "@rbxts/rlog";  
  
const config = { tag: "Datastore" };  
  
export function AddMoney(context: LogContext, player: Player, money: number) {  
  const logger = context.use(config);  
  
  logger.i("Adding money to player save");  
  // ...  
  logger.i("Money added");  
}

```

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

### Coroutine Running Comparison

Source: https://rlog.daymxn.com/docs/faq

Demonstrates how coroutine references can differ across asynchronous boundaries in JavaScript/TypeScript, highlighting a challenge for context tracking.

```typescript
async function DoOtherThing() {
	return coroutine.running();
}

async function DoThing() {
	const thread = coroutine.running();
	const otherThread = await DoOtherThing();

	// thread !== otherThread
	assert(thread === otherThread);
}
```

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

### Integrate Custom Logging with Context and Remotes

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Use `withLogContext` to manage log contexts and integrate custom logging configurations, such as the 'Actions' tag and custom formatting, with remote event handlers.

```typescript
import { withLogContext, LogConfig } from "@rbxts/rlog";
import { remotes } from "./remotes";
import { buyPet } from "./pets";

const config: LogConfig = { tag: "Remotes" };

remotes.buyPet.connect((player: Player, pet: PetId) => {
  withLogContext((context) => {
    const logger = context.use(config);
    logger.i("Player asked to buy a pet", { player: player, pet: pet });

    buyPet(context, player.UserId, pet);
  });
});

```

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

### Configure rLog with Custom Settings

Source: https://rlog.daymxn.com/docs/quick-start

Configure rLog with advanced options such as minimum log level, tags, custom enrichers, and serialization settings. This allows for fine-grained control over logging behavior.

```typescript
import { rLog, LogLevel } from "@rbxts/rlog";  
  
// Advanced setup with custom serialization and enrichers  
const logger = new rLog({  
	minLogLevel: LogLevel.WARNING,  
	tag: "Main",  
	enrichers: [  
		(entry) => {  
			entry.encoded_data.timestamp = DateTime.now().ToIsoDate();  
			return entry;  
		},  
	],  
	serialization: {  
		encodeFunctions: true,  
	},  
});  
```

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

### Customizing robloxConsoleSink with OutputMethod

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Shows how to override the default console output behavior using the `outputMethod` option in `robloxConsoleSink`.

```APIDOC
## Customizing robloxConsoleSink with OutputMethod

### Description
Enables customization of where and how formatted log messages are sent to the Roblox console via a custom `outputMethod`.

### Method
POST

### Endpoint
/api/rlog/config/custom-output

### Parameters
#### Request Body
- **sinks** (array) - Required - An array of sink configurations. This example includes `robloxConsoleSink` with a custom `outputMethod`.
  - **outputMethod** (callback) - Optional - A function that takes a `LogEntry` and the formatted messages (`LuaTuple`) and handles the output.

### Request Example
```json
{
  "sinks": [
    {
      "type": "robloxConsoleSink",
      "config": {
        "outputMethod": "customOutputMethod"
      }
    }
  ]
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates the configuration was updated successfully.

#### Response Example
```json
{
  "message": "Configuration with custom output method updated."
}
```
```

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

### withLogContext() Function

Source: https://rlog.daymxn.com/docs/api/rlog.withlogcontext_1

Wraps around a callback, automatically creating and managing the lifecycle for a LogContext. The callback is invoked immediately and in the same thread. Errors thrown within the callback are re-thrown after stopping the context to prevent memory leaks. Any value returned from the callback is also propagated.

```APIDOC
## withLogContext()

### Description
Wraps around a callback, automatically creating and managing the lifecycle for a LogContext.

### Signature
```typescript
export declare function withLogContext<R = void>(callback: ContextCallback<R>): R;
```

### Parameters
#### callback
- **callback** (ContextCallback<R>) - Required - ContextCallback scope to run and provide the context for.

### Returns
- R - The return value of the callback function.

### Remarks
The callback will be invoked immediately, and within the same thread.
Any errors thrown within the callback will be re-thrown after calling stop on the created context to avoid memory leaks.
Any value returned from the callback will also be propagated appropriately.

### Example
```typescript
remotes.buyPet.connect((player: Player, pet: PetId) => {
  // automatically starts and stops the context
  withLogContext((context) => {
    buyPet(context, player.UserId, pet);
  });
});
```
```

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

### Customizing robloxConsoleSink with FormatMethod

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Demonstrates how to customize the log message formatting using the `formatMethod` option within `robloxConsoleSink`.

```APIDOC
## Customizing robloxConsoleSink with FormatMethod

### Description
Allows customization of how log entries are converted into output objects using a custom `formatMethod`.

### Method
POST

### Endpoint
/api/rlog/config/custom-format

### Parameters
#### Request Body
- **sinks** (array) - Required - An array of sink configurations. This example includes `robloxConsoleSink` with a custom `formatMethod`.
  - **formatMethod** (callback) - Optional - A function that takes a `LogEntry` and returns a `LuaTuple` of arguments for the output method.

### Request Example
```json
{
  "sinks": [
    {
      "type": "robloxConsoleSink",
      "config": {
        "formatMethod": "customFormatMethod"
      }
    }
  ]
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates the configuration was updated successfully.

#### Response Example
```json
{
  "message": "Configuration with custom format method updated."
}
```
```

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

### Manage log context scopes

Source: https://rlog.daymxn.com/docs/basics/log-context

Use withLogContext and withLogContextAsync to provide configuration scopes for remote connections.

```typescript
import { withLogContext, LogLevel } from "@rbxts/rlog";  
import { remotes } from "./remotes";  
import { buyPet } from "./actions/pets";  
  
remotes.buyPet.connect((player: Player, pet: PetId) => {  
  withLogContext({ minLogLevel: LogLevel.DEBUG }, (context) => {  
    buyPet(context, player.UserId, pet);  
  });  
});  
```

```typescript
import { withLogContextAsync, LogLevel } from "@rbxts/rlog";  
import { remotes } from "./remotes";  
import { buyPet } from "./actions/pets";  
  
remotes.buyPet.onRequest((player: Player, pet: PetId) =>  
  withLogContextAsync({ minLogLevel: LogLevel.DEBUG }, async (context) => {  
    return buyPet(context, player.UserId, pet);  
  }),  
);  
```

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

### Give Money Function with Logging

Source: https://rlog.daymxn.com/docs/fast-breakdown

This function logs the action of giving money to a player and then calls the AddMoney function. It also uses `context.use` to obtain a logger with a specific tag.

```typescript
import { rLog, LogContext } from "@rbxts/rlog";  
import { AddMoney } from "./datastore";  
  
const config = { tag: "PlayerActions" };  
  
export function GiveMoney(context: LogContext, player: Player, money: number) {  
	const logger = context.use(config);  
  
	logger.i("Giving player money", { player: player, money: money });  
  
	AddMoney(context, player, money);  
  
	logger.i("Money given to player");  
}

```

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

### Verbose Logging in rLog

Source: https://rlog.daymxn.com/docs/basics/log-levels

Demonstrates using the verbose level and its shorthand alias 'v' for detailed application tracing.

```typescript
import { rLog } from "@rbxts/rlog";
import { sendPayment } from "./payment";

const logger = new rLog();
logger.verbose("Application started");

function processOrder(orderId: string, userId: string) {
	// All the logging methods have short hand aliases you can use as well
	logger.v("Fetching details for order", { order: orderId, user: userId });
}

processOrder("12345", "user789");
```

```text
[VERBOSE]: Application started
[VERBOSE]: Fetching details for order
{ data: { order: "12345", "user789" } }
```

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

### Logging with a Specific Tag

Source: https://rlog.daymxn.com/docs/basics/log-entries

Initializes the rLog logger with a specific tag for configuration, useful for differentiating log sources. Ensure rLog is imported.

```typescript
import { rLog } from "@rbxts/rlog";

const logger = new rLog({ tag: "Main" });

logger.info("Hello world!");
```

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

### Enable Function Logging

Source: https://rlog.daymxn.com/docs/basics/serialization

Use the encodeFunctions configuration option to include functions in log output as <Function> placeholders.

```typescript
import { rLog } from "@rbxts/rlog";  
  
function CreatePlayer(name: string) {  
	return {  
		name: name,  
		eatFood: () => {  
			// ...  
		},  
	};  
}  
  
const logger = new rLog({ serialization: { encodeFunctions: true } });  
  
const player = CreatePlayer("daymon");  
  
logger.i("Player created", { player: player });
```

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

### Set Log Context with RLog.withLogContext()

Source: https://rlog.daymxn.com/docs/api/rlog.rlog.withlogcontext

Use this method to create a new RLog instance with a specific context. The original RLog instance remains unchanged. This is useful for segmenting logs based on different parts of your application or different operational states.

```typescript
withLogContext(context: LogContext): RLog;
```

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

### Configure Roblox Console Sink with Custom Formatter

Source: https://rlog.daymxn.com/docs/basics/sinks

Shows how to update the default rLog configuration to use the robloxConsoleSink with a custom formatting method. This allows for customized log output in the Roblox console.

```typescript
import { rLog, robloxConsoleSink } from "@rbxts/rlog";
import { customFormatMethod } from "./custom-formatter";

rLog.UpdateDefaultConfig({
  sinks: [
    robloxConsoleSink({
      formatMethod: customFormatMethod,
    }),
  ],
});
```

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

### Create a Custom Consumer Sink to Log to Database

Source: https://rlog.daymxn.com/docs/basics/sinks

This sink sends log entries to a backend database. It conditionally queues log requests based on whether the environment is Studio or a published game, and only allows messages through to the Roblox console while in Studio.

```typescript
import { RunService } from "@rbxts/services";
import { rLog } from "@rbxts/rlog";
import { queueLogRequest } from "./log-database";

const debug = RunService.IsStudio();

export function logToDatabaseSink(entry: LogEntry): boolean {
  const endpoint = debug ? "qa" : "prod";

  queueLogRequest(entry, endpoint);

  return debug; // only allow messages through while we're in studio
}
```

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

### Debug Logging in rLog

Source: https://rlog.daymxn.com/docs/basics/log-levels

Demonstrates using the debug level and its shorthand alias 'd' for runtime diagnostic data.

```typescript
import { rLog } from "@rbxts/rlog";
import { sendPayment } from "./payment";

const logger = new rLog();

logger.verbose("Application started");

function processOrder(orderId: string, userId: string) {
	logger.v("Fetching details for order", { order: orderId, user: userId });

	const orderDetails = { items: ["item1", "item2"], total: 100 };

	logger.d(`Retrieved order details`, { details: orderDetails });
}

processOrder("12345", "user789");
```

```text
[VERBOSE]: Application started
[VERBOSE]: Fetching details for order
{ data: { order: "12345", "user789" } }

[DEBUG]: Retrieved order details
{ data: { details: { items: ["item1", "item2"], total: 100 } } }
```

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

### Handling Errors with rLog

Source: https://rlog.daymxn.com/docs/basics/log-levels

Shows how to catch exceptions and log them using the error level.

```typescript
import { rLog } from "@rbxts/rlog";  
import { sendPayment } from "./payment";  
  
const logger = new rLog();  
  
logger.verbose("Application started");  
  
function processOrder(orderId: string, userId: string) {  
	try {  
		logger.i("Processing order");  
  
		logger.v("Fetching details for order", { order: orderId, user: userId });  
  
		const orderDetails = { items: ["item1", "item2"], total: 1 };  
  
		logger.d(`Retrieved order details`, { details: orderDetails });  
  
		if (orderDetails.total < 10) {  
			logger.w("Order has a suspiciously low total");  
		}  
  
		logger.v("Sending order for payment");  
  
		const paymentSuccessful = sendPayment(order, userId, orderDetails);  
  
		if (!paymentSuccessful) {  
			logger.w("Payment for order failed");  
		}  
  
		logger.i("Order complete");  
	} catch (e) {  
		logger.e("An unexpected error occurred", {  
			reason: e.message,  
		});  
	}  
}  
  
processOrder("12345", 789);
```

```text
[VERBOSE]: Application started  
  
[INFO]: Processing order  
  
[VERBOSE]: Fetching details for order  
{ data: { order: "12345", 789 } }  
  
[DEBUG]: Retrieved order details  
{ data: { details: { items: ["item1", "item2"], total: 1 } } }  
  
[WARNING]: Order has a suspiciously low total  
  
[ERROR]: An unexpected error occurred  
{ data: { reason: "Invalid UserID provided! Expected a string, but got numbers!" } }
```

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

### Configure Minimum Log Level for Roblox Console Sink

Source: https://rlog.daymxn.com/docs/advanced/roblox-console-configuration

Set the minimum LogLevel to be output to the Roblox console. This allows other sinks to process higher levels while only displaying specific levels in the console.

```typescript
import { rLog, robloxConsoleSink, LogLevel } from "@rbxts/rlog";
  
rLog.UpdateDefaultConfig({
  sinks: [
    robloxConsoleSink({
      minLogLevel: LogLevel.DEBUG,
    }),
  ],
});

const logger = new rLog();

logger.i("Hello world!");
logger.d("Goodbye world!");

```

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

### Enable Context Suspension

Source: https://rlog.daymxn.com/docs/basics/log-context

Configure rLog to maintain log order by suspending output until the context closes.

```typescript
import { rLog, LogLevel, withLogContext } from "@rbxts/rlog";  
import { remotes } from "./remotes";  
import { buyPet } from "./actions/pets";  
  
rLog.UpdateDefaultConfig({  
  minLogLevel: LogLevel.INFO,  
  contextBypass: true,  
  suspendContext: true,  
});  
  
remotes.buyPet.connect((player: Player, pet: PetId) => {  
  // automatically starts and stops the context  
  withLogContextAsync((context) => buyPet(context, player.UserId, pet));  
});  
```

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

### Give Money Function with Log Context

Source: https://rlog.daymxn.com/docs/basics/log-context

This function shows how to use log context within a player action. It logs the intent to give money, calls the AddMoney function, and logs the completion of the money-giving action.

```typescript
import { rLog, LogContext } from "@rbxts/rlog";  
import { AddMoney } from "./datastore";  
  
const config = { tag: "PlayerActions" };  
  
export function GiveMoney(context: LogContext, player: Player, money: number) {  
  const logger = context.use(config);  
  
  logger.i("Giving player money", { player: player, money: money });  
  
  AddMoney(context, player, money);  
  
  logger.i("Money given to player");  
}

```

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

### Setting Minimum Log Level via Helper Method

Source: https://rlog.daymxn.com/docs/basics/log-levels

Uses the withMinLogLevel method to return a logger instance with a specific filter level.

```typescript
// returns a copy of this logger, but with the `minLogLevel` set to `DEBUG`  
const logger = new rLog().withMinLogLevel(LogLevel.DEBUG);
```

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

### Configure Tag on Instance Creation - rLog

Source: https://rlog.daymxn.com/docs/basics/tags

Configure the tag for an rLog instance when initializing it with specific configuration options. This also prefixes the tag to log messages.

```typescript
import { rLog } from "@rbxts/rlog";

const main = new rLog({ tag: "Main" });

main.i("Hello world!");
```

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

### Define and use custom encoding method

Source: https://rlog.daymxn.com/docs/api/rlog.serializationconfig.encodemethod

Demonstrates how to define an encode method in a class and configure RLog to use it for object serialization.

```typescript
class PlayerClass {  
  constructor(public name: string) {};  
  
  public encode() {  
   return { name: this.name };  
  }  
}  
  
const player = new PlayerClass("daymon");  
  
let logger = new RLog();  
  
logger.i("Player created", { player: player });  
// > [INFO]: Player created  
// > { "data": { "player": "PlayerClass" } }  
  
logger = new RLog({ serialization: { encodeMethod: "encode" } });  
  
logger.i("Player created", { player: player });  
// > [INFO]: Player created  
// > { "data": { "player": { "name": "daymon" } } }  
```

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

### Automatic Context Drilling - After

Source: https://rlog.daymxn.com/docs/faq

Shows the 'after' state of automatic context drilling via AST transformation, where log context is explicitly passed down the call stack.

```typescript
function SomeFunctionThatLogs(context: LogContext) {
	const logger = context.use();
	logger.info("Hello world!");
}

function SomeFunction(context: LogContext) {
	SomeFunctionThatLogs(context);
}

withLogContext((context) => {
	SomeFunction(context);
});  
```

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

### Enable Context Bypass

Source: https://rlog.daymxn.com/docs/basics/log-context

Configure rLog to bypass minLogLevel when a warning occurs within a context.

```typescript
import { rLog, LogLevel, withLogContext } from "@rbxts/rlog";  
import { remotes } from "./remotes";  
import { buyPet } from "./actions/pets";  
  
rLog.UpdateDefaultConfig({ minLogLevel: LogLevel.INFO });  
  
remotes.buyPet.connect((player: Player, pet: PetId) => {  
  // automatically starts and stops the context  
  withLogContextAsync({ contextBypass: true }, (context) => buyPet(context, player.UserId, pet));  
});  
```

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

### Log Context Annotation - After

Source: https://rlog.daymxn.com/docs/faq

Illustrates how the `@LogContext` annotation and `withLogContext` would function after automatic transformation, passing context as a parameter.

```typescript
function SomeFunction(context: LogContext) {
	const logger = context.use();
	// ...
}

withLogContext((context) => {
	SomeFunction(context);
});  
```

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

### Flush Logs on Close

Source: https://rlog.daymxn.com/docs/basics/log-context

Use bindToClose to ensure pending logs are flushed before the game shuts down.

```typescript
import { rLog } from "@rbxts/rlog";  
  
game.bindToClose(() => {  
  rLog.ForceContextFlush();  
});  
```
Tokens:
Raw