ha mode polish

Author: dev-dist

src/content/data-streams/tutorials/go-sdk-stream.mdx

@@ -327,53 +327,49 @@ The decoded report details include:
 
 For descriptions and data types of other report schemas, see the [Report Schema Overview](/data-streams/reference/report-schema-overview).
 
+### Subscribing to multiple streams
+
+You can subscribe to multiple streams by providing additional stream IDs as command-line arguments:
+
+```bash
+go run stream.go 0x000359843a543ee2fe414dc14c7e7920ef10f4372990b79d6361cdc0dd1ba782 0x00036fe43f87884450b4c7e093cd5ed99cac6640d8c2000e6afc02c8838d0265
+```
+
+This will subscribe to both ETH/USD and BTC/USD streams.
+
 ### High Availability (HA) mode
 
 <Aside type="note" title="Mainnet only">
   HA mode is only available on mainnet endpoints, not testnet.
 </Aside>
 
-High Availability (HA) mode creates multiple WebSocket connections to different origin endpoints for improved reliability. When enabled, the SDK automatically handles failover, deduplicates reports, and provides connection-level metrics.
+The example above demonstrates streaming data from a single crypto stream. For production environments, especially when subscribing to multiple streams, it's recommended to enable [High Availability (HA) mode](/data-streams/reference/data-streams-api/go-sdk#high-availability-ha-mode).
+
+High Availability (HA) mode creates multiple WebSocket connections to different origin endpoints for improved reliability. When HA mode is enabled, the Stream will maintain at least 2 concurrent connections to different instances to ensure high availability, fault tolerance and minimize the risk of report gaps.
 
 #### Enabling HA mode
 
 To enable HA mode in your streaming application, make these changes to the basic example:
 
-1. Add HA mode to the client configuration and use a mainnet endpoint, as HA mode is not currently supported on testnet:
-
 ```go
+// ... existing code ...
+
+// Enable HA mode with mainnet endpoint
 cfg := streams.Config{
     ApiKey:    os.Getenv("API_KEY"),
     ApiSecret: os.Getenv("API_SECRET"),
     WsURL:     "wss://ws.dataengine.chain.link", // Use mainnet endpoint for HA mode
     WsHA:      true,                             // Enable High Availability mode
     Logger:    streams.LogPrintf,
 }
-```
-
-2. Monitor HA metrics using the existing `Stats()` calls in your report handler:
-
-```go
-// In your report processing loop
-for {
-    reportResponse, err := stream.Read(context.Background())
-    if err != nil {
-        cfg.Logger("Error reading from stream: %v\n", err)
-        continue
-    }
-
-    // Process the report...
 
-    // Monitor HA statistics (includes HA-specific metrics)
-    cfg.Logger("Stream Stats: %s\n", stream.Stats().String())
-    // Output example: "accepted: 150, deduplicated: 3, total_received: 153, partial_reconnects: 1, full_reconnects: 0, configured_connections: 2, active_connections: 2"
+client, err := streams.New(cfg)
+if err != nil {
+    cfg.Logger("Failed to create client: %v\n", err)
+    os.Exit(1)
 }
-```
 
-3. Optionally, monitor individual connection status using `StreamWithStatusCallback`:
-
-```go
-// Subscribe to the feeds with connection status monitoring
+// Optional: Use StreamWithStatusCallback for connection monitoring
 stream, err := client.StreamWithStatusCallback(
     ctx, ids,
     func(isConnected bool, host string, origin string) {
@@ -384,21 +380,15 @@ stream, err := client.StreamWithStatusCallback(
         cfg.Logger("Host: %s, Origin: %s, Status: %s\n", host, origin, status)
     },
 )
-```
-
-When HA mode is enabled, the SDK maintains at least 2 concurrent connections to different instances to ensure high availability, fault tolerance, and minimize the risk of report gaps.
-
-See more details about HA mode in the [SDK Reference](/data-streams/reference/data-streams-api/go-sdk#high-availability-ha-mode).
 
-### Subscribing to multiple streams
+// ... existing code ...
+```
 
-You can subscribe to multiple streams by providing additional stream IDs as command-line arguments:
+When `WsHA` is `true`, the SDK automatically discovers multiple origin endpoints behind the single URL and establishes separate connections to each origin. You also must use a mainnet endpoint, as HA mode is not currently supported on testnet.
 
-```bash
-go run stream.go 0x000359843a543ee2fe414dc14c7e7920ef10f4372990b79d6361cdc0dd1ba782 0x00036fe43f87884450b4c7e093cd5ed99cac6640d8c2000e6afc02c8838d0265
-```
+The optional `StreamWithStatusCallback` can be used to monitor individual connection status. The SDK already provides comprehensive connection logs through `stream.Stats().String()`, so this callback is primarily useful for custom alerting or connection monitoring.
 
-This will subscribe to both ETH/USD and BTC/USD streams.
+See more details about HA mode in the [SDK Reference](/data-streams/reference/data-streams-api/go-sdk#high-availability-ha-mode).
 
 ### Payload for onchain verification
 

src/content/data-streams/tutorials/rust-sdk-stream.mdx

@@ -310,25 +310,6 @@ In this tutorial, you'll learn how to use the [Data Streams SDK](/data-streams/r
 
    [Learn more about the decoded report details](#decoded-report-details).
 
-### High Availability (HA) Mode
-
-The example above demonstrates streaming data from a single crypto stream. For production environments, especially when subscribing to multiple streams, it's recommended to enable [High Availability (HA) mode](https://github.com/smartcontractkit/data-streams-sdk/blob/main/rust/docs/examples/wss_multiple.md). This can be achieved by:
-
-1. Adding multiple WebSocket endpoints in the configuration:
-
-   ```rust
-   "wss://ws.testnet-dataengine.chain.link,wss://ws.testnet-dataengine.chain.link"
-   ```
-
-1. Enabling HA mode in the configuration:
-   ```rust
-   use chainlink_data_streams_sdk::config::WebSocketHighAvailability;
-   // ...
-   .with_ws_ha(WebSocketHighAvailability::Enabled)
-   ```
-
-When HA mode is enabled and multiple WebSocket origins are provided, the Stream will maintain concurrent connections to different instances. This ensures high availability, fault tolerance, and minimizes the risk of report gaps.
-
 #### Subscribing to multiple streams
 
 You can subscribe to multiple streams by providing additional stream IDs as command-line arguments:
@@ -341,6 +322,41 @@ cargo run -- \
 
 This will subscribe to both ETH/USD and BTC/USD streams.
 
+### High Availability (HA) mode
+
+<Aside type="note" title="Mainnet only">
+  HA mode is only available on mainnet endpoints, not testnet.
+</Aside>
+
+The example above demonstrates streaming data from a single crypto stream. For production environments, especially when subscribing to multiple streams, it's recommended to enable [High Availability (HA) mode](/data-streams/reference/data-streams-api/rust-sdk#high-availability-mode).
+
+High Availability (HA) mode creates multiple WebSocket connections to different origin endpoints for improved reliability. When HA mode is enabled, the Stream will maintain at least 2 concurrent connections to different instances to ensure high availability, fault tolerance and minimize the risk of report gaps.
+
+#### Enabling HA mode
+
+To enable HA mode in your streaming application, make these changes to the basic example. You also must use a mainnet endpoint, as HA mode is not currently supported on testnet.
+
+```rust
+// ... existing code ...
+
+use chainlink_data_streams_sdk::config::{Config, WebSocketHighAvailability}; // Import WebSocketHighAvailability
+
+// Initialize the configuration with HA mode
+let config = Config::new(
+    api_key,
+    api_secret,
+    "https://api.dataengine.chain.link".to_string(), // Mainnet endpoint
+    "wss://ws.dataengine.chain.link,wss://ws.dataengine.chain.link".to_string(), // Multiple WebSocket endpoints
+)
+.with_ws_ha(WebSocketHighAvailability::Enabled) // Enable WebSocket High Availability Mode
+.build()?;
+
+
+// ... existing code ...
+```
+
+See more details about HA mode in the [SDK Reference](/data-streams/reference/data-streams-api/rust-sdk#high-availability-mode).
+
 ### Decoded report details
 
 The decoded report details include:
@@ -359,14 +375,6 @@ The decoded report details include:
 
 For descriptions and data types of other report schemas, see the [Report Schema Overview](/data-streams/reference/report-schema-overview).
 
-### High Availability (HA) mode
-
-<Aside type="note" title="Mainnet only">
-  HA mode is only available on mainnet endpoints, not testnet.
-</Aside>
-
-High Availability (HA) mode creates multiple WebSocket connections to different origin endpoints for improved reliability. When enabled, the SDK automatically handles failover, deduplicates reports, and provides connection-level metrics.
-
 ### Payload for onchain verification
 
 In this tutorial, you logged and decoded the `full_report` payloads to extract the report data. However, in a production environment, you should verify the data to ensure its integrity and authenticity.

src/content/data-streams/tutorials/ts-sdk-stream.mdx

@@ -346,77 +346,66 @@ The decoded report details include:
 
 For descriptions and data types of other report schemas, see the [Report Schema Overview](/data-streams/reference/report-schema-overview).
 
+### Subscribing to multiple streams
+
+You can subscribe to multiple streams by providing additional stream IDs as command-line arguments:
+
+```bash
+npx tsx stream.ts 0x000359843a543ee2fe414dc14c7e7920ef10f4372990b79d6361cdc0dd1ba782,0x00036fe43f87884450b4c7e093cd5ed99cac6640d8c2000e6afc02c8838d0265
+```
+
+This will subscribe to both ETH/USD and BTC/USD streams.
+
 ### High Availability (HA) mode
 
 <Aside type="note" title="Mainnet only">
   HA mode is only available on mainnet endpoints, not testnet.
 </Aside>
 
-High Availability (HA) mode creates multiple WebSocket connections to different origin endpoints for improved reliability. When enabled, the SDK automatically handles failover, deduplicates reports, and provides connection-level metrics.
+The example above demonstrates streaming data from a single crypto stream. For production environments, especially when subscribing to multiple streams, it's recommended to enable [High Availability (HA) mode](/data-streams/reference/data-streams-api/ts-sdk#high-availability-mode).
+
+High Availability (HA) mode creates multiple WebSocket connections to different origin endpoints for improved reliability. When HA mode is enabled, the Stream will maintain at least 2 concurrent connections to different instances to ensure high availability, fault tolerance and minimize the risk of report gaps.
 
 #### Enabling HA mode
 
 To enable HA mode in your streaming application, make these changes to the basic example:
 
-1. Add `haMode: true` to the client configuration. You also must use a mainnet endpoint, as HA mode is not currently supported on testnet.
-
 ```typescript
+// ... existing code ...
+
 const client = createClient({
   apiKey: process.env.API_KEY || "YOUR_API_KEY",
   userSecret: process.env.USER_SECRET || "YOUR_USER_SECRET",
   endpoint: "https://api.dataengine.chain.link", // Mainnet endpoint
-  wsEndpoint: "wss://ws.dataengine.chain.link", // Mainnet WebSocket
+  wsEndpoint: "wss://ws.dataengine.chain.link", // Single endpoint (mainnet only)
   haMode: true, // Enable High Availability mode
 
-  // Optional: Monitor connection status changes
-  connectionStatusCallback: (isConnected: boolean, host: string, origin?: string) => {
-    const status = isConnected ? "🟢 Connected" : "🔴 Disconnected"
-    console.log(`${status}: ${host}${origin ? ` (${origin})` : ""}`)
+  // Optional: Advanced connection monitoring with origin tracking
+  connectionStatusCallback: (isConnected, host, origin) => {
+    const timestamp = new Date().toISOString().substring(11, 19)
+    const status = isConnected ? "🟢 UP" : "🔴 DOWN"
+    console.log(`[${timestamp}] ${status} ${host}${origin || ""}`)
+
+    // Example: Send alerts for specific origins
+    if (!isConnected && origin) {
+      console.warn(`⚠️ Alert: Origin ${origin} on ${host} went offline`)
+    }
   },
 
   logging: {
     logger: console,
     logLevel: LogLevel.INFO,
   },
 })
-```
-
-2. Optionally, monitor HA metrics using the existing `getMetrics()` calls in your report handler:
 
-```typescript
-stream.on("report", (report) => {
-  // ... your report processing logic
-
-  // HA-specific metrics
-  const stats = stream.getMetrics()
-  console.log(
-    `📊 HA Stats: ${stats.accepted} reports | ${stats.activeConnections}/${stats.configuredConnections} connections`
-  )
-  console.log(`Reconnects: ${stats.partialReconnects} partial, ${stats.fullReconnects} full`)
-
-  // Check deduplication (important for HA mode)
-  if (stats.totalReceived > 0) {
-    const deduplicationRate = ((stats.deduplicated / stats.totalReceived) * 100).toFixed(1)
-    console.log(`📈 Deduplication: ${deduplicationRate}% (${stats.deduplicated} filtered)`)
-  }
-})
+// ... existing code ...
 ```
 
-When `haMode` is `true`, the SDK automatically discovers multiple origin endpoints behind the single URL and establishes separate connections to each origin.
+When `haMode` is `true`, the SDK automatically discovers multiple origin endpoints behind the single URL and establishes separate connections to each origin. You also must use a mainnet endpoint, as HA mode is not currently supported on testnet.
 
 The optional `connectionStatusCallback` can be used to integrate with external monitoring systems. The SDK already provides comprehensive connection logs, so this callback is primarily useful for custom alerting or metrics collection.
 
-See more details about HA mode in the [SDK Reference](/ts-sdk#high-availability-mode).
-
-### Subscribing to multiple streams
-
-You can subscribe to multiple streams by providing additional stream IDs as command-line arguments:
-
-```bash
-npx tsx stream.ts 0x000359843a543ee2fe414dc14c7e7920ef10f4372990b79d6361cdc0dd1ba782,0x00036fe43f87884450b4c7e093cd5ed99cac6640d8c2000e6afc02c8838d0265
-```
-
-This will subscribe to both ETH/USD and BTC/USD streams.
+See more details about HA mode in the [SDK Reference](/data-streams/reference/data-streams-api/ts-sdk#high-availability-ha-mode).
 
 ### Payload for onchain verification