Logging

This guide will go over how the GLIDE clients logger works and how to configure it.

How Logging Works

Valkey GLIDE clients are built upon a shared, high-performance Rust Core that utilizes a singleton logger exposed via the Foreign Function Interface (FFI). This architecture allows client wrappers to configure the logger and push their own messages directly into the core, ensuring that all logs remain synchronized and preserve the order of events.

Currently, GLIDE does not support direct integration with third-party logging libraries. While there is interest in adding this capability, it has not yet been prioritized. If this functionality is critical for your use case, we encourage you to submit a feature request to the Valkey GLIDE GitHub.

The logger is currently available for C#, Python, Node, Java, and PHP clients.

Examples

The following examples show how to configure the logger in GLIDE clients.

Python

import asyncio
from glide import GlideClientConfiguration, NodeAddress, GlideClient, Logger, LogLevel

async def test_cluster_client():
    # Configure the log level and the log file name
    Logger.set_logger_config(level = LogLevel.DEBUG, file_name="./glide_logs")

    # Logging example
    Logger.log(log_level=LogLevel.INFO, log_identifier= "LoggingExample", message = "Hello World!")

    # Standalone client configuration
    addresses = [NodeAddress("localhost", 6379)]
    config = GlideClientConfiguration(addresses)
    client = await GlideClient.create(config)
    await client.ping()

asyncio.run(test_cluster_client())

Refer to the API reference for the full logger interface.

Node

import { GlideClient, Logger } from "@valkey/valkey-glide";

// Configure the log level and the output file name.
Logger.setLoggerConfig("debug", "./glide_logs");

// Logging example
const message = "Hello World!";
const identifier = "LoggingExample";
Logger.log("info", identifier, message);

// Standalone client configuration
const addresses = [{ host: "localhost", port: 6379 }];
const client = await GlideClient.createClient({
  addresses: addresses,
});

await client.ping();

Refer to the API reference for the full logger interface.

C#

using Valkey.Glide;
using static Valkey.Glide.ConnectionConfiguration;

// Configure the log level and the output file name.
Logger.SetLoggerConfig(Level.Debug, "./glide_logs");

// Logging example
Logger.Log(Level.Info, "LoggingExample", "Hello World!");

// Standalone client configuration
var config = new StandaloneClientConfigurationBuilder()
    .WithAddress("localhost", 6379)
    .Build();

// Create a standalone client
await using var client = await GlideClient.CreateClient(config);
await client.PingAsync();

Refer to the API reference for the full logger interface.

Java

package com.example;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import glide.api.GlideClient;
import glide.api.logging.Logger;
import glide.api.models.configuration.GlideClientConfiguration;
import glide.api.models.configuration.NodeAddress;

public class ValkeyPingExample {

    public static void main(String[] args) {

        // Configure the log level and the output file name.
        String logFile = "./glide_logs";
        Logger.setLoggerConfig(Logger.Level.DEBUG, logFile);

        // Logging example
        String identifier = "LoggingExample";
        Logger.log(Logger.Level.INFO, identifier, "Hello World!");

        String host = "localhost";
        Integer port = 6379;
        GlideClientConfiguration config =
            GlideClientConfiguration.builder()
                    .address(NodeAddress.builder().host(host).port(port).build())
                    .build();

        // Create a standalone client
        try (GlideClient client = GlideClient.createClient(config).get()) {
            CompletableFuture<String> result = client.ping();
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Refer to the API reference for the full logger interface.

PHP

// Configure the log level and the output file name
valkey_glide_logger_set_config("debug", "./glide_logs");

// Logging example
$identifier = "LoggingExample";
valkey_glide_logger_log("info", $identifier, "Hello World!");

// Standalone client configuration
$addresses = [
    ['host' => 'localhost', 'port' => 6379]
];

$client = new ValkeyGlide();
$client->connect(addresses: $addresses);
$client->ping();

Refer to the logger functions for the full logger interface.

Log Files

By default, logs are output to stdout. However, you can configure the logger to write logs to a file by specifying a file name in the configuration methods shown in the examples above.

If the file name is an absolute path /example/logs/client_logs, the logs will be written to the file /example/logs/client_logs.<timestamp>.

If the file name is a relative path ./client_logs, the logs will be written inside the folder glide-logs. For example, ./glide-logs/client_logs.<timestamp>.

To prevent large files, log files are rotated hourly.

Cleanup Outputs

Since logs are outputted from the Rust layer, it contains ANSI color code for console outputs. These codes may appear in log files as unknown characters or character codes. To disable these color codes, you can set the environment variable NO_COLOR=1 before starting the logger.

Recommended Configuration

For development and debugging, use DEBUG level to see all internal operations including connection management, topology refreshes, and command routing.

For production, use WARN level with file output. This captures connectivity issues, timeouts, and performance degradation without the overhead of verbose logging.

Refer to the examples above for language-specific configuration.

Understanding Log Output

GLIDE log messages follow this format:

<timestamp> <LEVEL> <component> - <message>

For example:

2026-05-01T19:14:23.081Z  WARN logger_core: cluster - disconnected from "172.30.0.11:6379"

Key components you may see in logs:

Component	Description
cluster	Cluster connection management, routing errors, disconnections
pipeline	Command pipeline send/receive, backpressure warnings
connections_logic	Connection health checks and reconnection
moved_error	Slot map changes and MOVED/ASK redirect handling
inflight	Inflight request tracking and limit enforcement
AsyncRegistry	Java-side future tracking and timeout delivery
jni_command	JNI layer command dispatch timing