Logging for Rust SDK

This page explains how to enable logging in the PubNub Rust Software Development Kit (SDK) using standard Rust logging facilities.

How to enable logging

The PubNub Rust SDK uses the standard Rust logging framework (log crate) internally. To capture these logs, you need to initialize a logger implementation in your application.

Setup with env_logger

The simplest way to enable logging is to use the env_logger crate, which is included as a dependency of the SDK:

1use std::env;
2use std::error::Error;
3

4use env_logger::{self, Env};
5use log::{debug, error, info, warn};
6use pubnub::{channel_groups::ChannelGroups, core::PubNubError, Keyset, PubNubClientBuilder};
7use tokio;
8

9#[tokio::main]
10async fn main() -> Result<(), Box<dyn Error>> {
11    // Configure and initialize the logger before creating the PubNub client
12    // You can control log level via the RUST_LOG environment variable
13    // Examples:
14    //   RUST_LOG=debug cargo run  # Show debug and higher logs
15    //   RUST_LOG=info cargo run   # Show info and higher logs
16    //   RUST_LOG=trace cargo run  # Show all logs
17    env_logger::Builder::from_env(Env::default().default_filter_or("info"))
18        .format_timestamp_millis()
19        .init();
20

21    info!("Initializing PubNub client with logging enabled");
22

23    // Initialize PubNub client with demo keys
24    let pubnub = PubNubClientBuilder::with_reqwest_transport()
25        .with_keyset(Keyset {
26            // Replace "demo" with your Publish Key from the PubNub Admin Portal
27            publish_key: Some("demo"),
28            // Replace "demo" with your Subscribe Key from the PubNub Admin Portal
29            subscribe_key: "demo",
30            secret_key: None,
31        })
32        .with_user_id("rust-logging-demo-user")
33        .build()
34        .map_err(|err| {
35            error!("Failed to initialize PubNub client: {:?}", err);
36            err
37        })?;
38

39    info!("PubNub client initialized successfully");
40    debug!("Client configuration: subscribe_key=demo, user_id=rust-logging-demo-user");
41

42    // Perform operations to generate logs
43    perform_operations(&pubnub).await?;
44

45    info!("Logging example completed");
46    Ok(())
47}
48

49async fn perform_operations(
50    pubnub: &pubnub::PubNubClient<reqwest::Client>,
51) -> Result<(), PubNubError> {
52    // Get PubNub time (simple operation to generate logs)
53    info!("Fetching PubNub time to generate logs...");
54    let time_result = pubnub.time().execute().await?;
55    info!("Current PubNub time: {}", time_result);
56

57    // Publish a message (generates more logs)
58    let channel = "logging-demo-channel";
59    info!("Publishing a message to channel '{}'...", channel);
60

61    let publish_result = pubnub
62        .publish_message("Hello from Rust logging example!")
63        .channel(channel)
64        .r#type("text-message")
65        .execute()
66        .await?;
67

68    info!(
69        "Message published with timetoken: {}",
70        publish_result.timetoken
71    );
72

73    // Get Here Now data (generates more logs)
74    info!("Fetching Here Now data...");
75    let here_now_result = pubnub
76        .here_now()
77        .channels([channel.to_string()].to_vec())
78        .include_state(true)
79        .include_user_id(true)
80        .execute()
81        .await?;
82

83    here_now_result.iter().for_each(|channel_data| {
84        info!(
85            "Channel: {}, Occupancy: {}",
86            channel_data.name, channel_data.occupancy
87        );
88    });
89

90    // Demonstrate different log levels
91    debug!("This is a debug message - only shown when RUST_LOG includes debug level");
92    info!("This is an info message - shown by default in this example");
93    warn!("This is a warning message - shown by default and highlighted");
94    error!("This is an error message - also shown by default and highlighted");
95

96    Ok(())
97}

show all 97 lines

Log levels

The Rust SDK uses standard log levels from the log crate:

Log Level	Description
error	Critical errors that may prevent the SDK from functioning correctly
warn	Warning conditions that don't prevent the SDK from functioning but might indicate issues
info	Informational messages about normal operations
debug	Detailed information useful for debugging
trace	Very detailed information about internal operations

Setting log levels

You can control which log messages are displayed by setting the RUST_LOG environment variable:

1# Display all logs including debug information
2RUST_LOG=debug cargo run
3

4# Display only warnings and errors
5RUST_LOG=warn cargo run
6

7# Display all trace logs for the pubnub crate
8RUST_LOG=pubnub=trace cargo run
9

10# Display debug logs for pubnub and warning logs for everything else
11RUST_LOG=warn,pubnub=debug cargo run

Protect sensitive data

The PubNub Rust SDK logs network activity at the info level, not just debug/trace. Enabling info-level logs is enough to expose sensitive data. Never enable info, debug, or trace logging for the PubNub Rust SDK crate in production environments that handle sensitive information.

These levels may expose:

• Complete request URLs, including Access Manager signature, auth, and timestamp query parameters used for signed requests
• Complete response bodies, including the full token string returned by grant_token calls
• API keys, user identifiers, and message content

Network protocol logging

Starting in version 0.8.0, the default TransportReqwest logs the negotiated HTTP protocol at the debug level after each completed request. This applies to both the native async and blocking transports. On wasm32 targets, the protocol is negotiated by the host's environment (e.g. browser) fetch stack rather than the SDK, so this log entry doesn't reliably reflect the negotiated HTTP version.

Each log entry includes the HTTP method, request path, and the protocol version reported by reqwest:

Request completed: method=GET path=/v2/subscribe/demo/demo/0/my_channel/0 protocol=HTTP/2.0

To see protocol logs without enabling debug output for the entire SDK:

1RUST_LOG=pubnub::transport::reqwest=debug cargo run
2

3# Combine with other modules as needed:
4

5RUST_LOG=pubnub::transport::reqwest=debug,pubnub::core::event_engine=debug cargo run

Protocol logging is useful when validating HTTP/2 negotiation against supported origins (for example, https://h2.pubnubapi.com) or when troubleshooting subscribe reconnects where the negotiated protocol may change. For HTTP/2 behavior and reconnect details, refer to HTTP/2 transport.

Complete example

Here's a complete example showing how to set up logging with PubNub:

1use std::error::Error;
2use env_logger;
3use log::{debug, error, info, warn};
4use pubnub::{PubNubClientBuilder, Keyset};
5use tokio;
6

7#[tokio::main]
8async fn main() -> Result<(), Box<dyn Error>> {
9    // Initialize the logger first - this should be done before any logging occurs
10    env_logger::init();
11    
12    info!("Initializing PubNub client with logging enabled");
13    
14    // Then initialize PubNub with demo keys
15    let client = PubNubClientBuilder::with_reqwest_transport()
16        .with_keyset(Keyset {
17            publish_key: Some("demo"), // Replace with your Publish Key from the PubNub Admin Portal
18            subscribe_key: "demo",     // Replace with your Subscribe Key from the PubNub Admin Portal
19            secret_key: None,
20        })
21        .with_user_id("logging-example-user")
22        .build()
23        .expect("Failed to create PubNub client");
24    
25    debug!("PubNub client initialized successfully");
26    
27    // Example operation to generate logs
28    match client.time().execute().await {
29        Ok(time) => {
30            info!("Successfully retrieved PubNub time: {}", time);
31        },
32        Err(err) => {
33            error!("Failed to retrieve time: {:?}", err);
34        }
35    }
36    
37    // Example publish operation
38    let channel = "logging-demo-channel";
39    match client.publish_message("Hello with logging!")
40        .channel(channel)
41        .execute()
42        .await 
43    {
44        Ok(result) => {
45            info!("Message published successfully to {} with timetoken: {}", 
46                channel, result.timetoken);
47        },
48        Err(err) => {
49            error!("Failed to publish message: {:?}", err);
50        }
51    }
52    
53    warn!("This is an example warning message");
54    debug!("This is an example debug message - only visible with RUST_LOG=debug or lower");
55    
56    Ok(())
57}

show all 57 lines