Fixed documentation mistakes

Author: stefanrammo

DOCUMENTATION.md

@@ -82,7 +82,7 @@ Before using the CDP Logger Client, make sure you have the following:
 
 - **ProtoBuf JS** – The library depends on `protobufjs` (included as an npm dependency). If you installed via npm and are using a bundler or Node, this will be installed automatically. If you are using direct script includes, include the `protobuf.min.js` as shown above.
 
-- **CDP Logger API Compatibility** – As noted, the target CDP Logger should be running a version that supports the queries you need. Basic data queries work on older versions (3.0+), but features like tags and advanced event filtering require newer CDP releases (CDP 4.12 for tags support, etc.). If you’re running an older CDP version and some API calls fail or are not supported, consider upgrading CDP Studio or limiting to the supported features.
+- **CDP Logger API Compatibility** – As noted, the target CDP Logger should be running a version that supports the queries you need. Basic data queries work on older versions (CDP 4.3+), but features like tags and advanced event filtering require newer CDP releases (CDP 4.12 for tags support, etc.). If you’re running an older CDP version and some API calls fail or are not supported, consider upgrading CDP Studio or limiting to the supported features.
 
 ## Setup and Configuration
 
@@ -149,7 +149,6 @@ A few notes on the above example:
 You can also request historical **data points** for one or more signals using `client.requestDataPoints(names, startTimeSec, endTimeSec, numberOfPoints)`. For example:
 
 ```js
-// Assume we got `limits` from requestLogLimits (which provides start and end of log):
 const limits = await client.requestLogLimits();
 const start = limits.startS;
 const end   = limits.endS;
@@ -175,15 +174,15 @@ The above demonstrates retrieving 100 aggregated data points between the earlies
 Finally, to retrieve **events**, you can use `client.requestEvents(query)` along with constructing a query object. You can also use `client.countEvents(query)` to just get the count. Here’s a brief Node example for events:
 
 ```js
-const query = {
+const query = { // Note: all query arguments are optional
   senderConditions: [
     { value: "MyApp.AlarmManager", matchType: MatchType.Exact }
   ],
   dataConditions: {
     // Assume events have a field "Text" and we want those containing "Overheat"
     Text: ["Overheat*"]  // '*' wildcard is the default option
   },
-  timeRangeStart: Date.now()/1000 - 24*3600,  // (optional) last 24 hours in seconds (if time filtering desired)
+  timeRangeStart: Date.now()/1000 - 24*3600,  // last 24 hours in seconds (if time filtering desired)
   limit: 50,      // max 50 events
   offset: 0,      // start from the first match
   flags: EventQueryFlags.NewestFirst  // get newest events first
@@ -218,7 +217,7 @@ Using the client in a browser is similar, except you don’t need to polyfill We
 
 <script>
   // Once scripts are loaded, use the global cdplogger
-  const client = new cdplogger.Client("ws://localhost:17000");  // connect to logger
+  const client = new cdplogger.Client(window.location.hostname + ":17000"); // Connect to logger
   
   // Example: fetch API version
   client.requestApiVersion().then(version => {
@@ -238,11 +237,9 @@ As shown, the usage is very much the same as in Node. The `cdplogger.Client` cla
 
 A few browser-specific notes:
 
-- **Security:** If your CDP Logger is served over HTTPS (or you are accessing it from an HTTPS page), use `wss://` for the WebSocket URL to avoid mixed content issues. Ensure the CDP Logger is configured with TLS if needed. For local testing with `http://localhost` you can use `ws://` without issues.
-
 - **CORS/WebSocket Policy:** WebSocket connections are not subject to the same-origin policy in the way XHR/Fetch are, but some environments might still require the server to accept the connection. The CDP Logger’s WebSocket server should accept connections from any origin by default. If you encounter issues connecting from a web page, check if any firewall or network configuration is blocking the websocket port.
 
-- **Performance:** Retrieving a lot of data points or events in one go can be heavy for the browser. If you plan to visualize large data sets, consider using pagination (e.g., request events 100 at a time using `offset`) or downsampling data points via the `numberOfPoints` parameter. The library itself streams the data efficiently, but rendering thousands of points in the DOM can be slow, so plan accordingly.
+- **Performance:** Retrieving a lot of data points or events in one go can be heavy for the browser. If you plan to visualize large data sets, consider using pagination (e.g., request events 100 at a time using `offset`) or downsampling data points via the `noOfDataPoints` parameter. The library itself streams the data efficiently, but rendering thousands of points in the DOM can be slow, so plan accordingly.
 
 ## How to Run Tests
 
@@ -293,4 +290,4 @@ This project is open-source software licensed under the **MIT License**. See the
 
 ---
 
-*Thank you for using the JavaScript CDP Logger Client!* We hope this library makes it easier to integrate CDP Studio’s powerful logging capabilities into your own tools and applications. ([GitHub - CDPTechnologies/JavascriptCDPLoggerClient: A simple Javascript interface to communicate with CDP applications containing a CDPLogger component to retrieve historic data.](https://github.com/CDPTechnologies/JavascriptCDPLoggerClient#:~:text=A%20simple%20JavaScript%20interface%20for,com))
+*Thank you for using the JavaScript CDP Logger Client!* We hope this library makes it easier to integrate CDP Studio’s powerful logging capabilities into your own tools and applications. ([GitHub - CDPTechnologies/JavascriptCDPLoggerClient](https://github.com/CDPTechnologies/JavascriptCDPLoggerClient#:~:text=A%20simple%20JavaScript%20interface%20for,com))

QUICKSTART.md

@@ -4,7 +4,7 @@ This guide demonstrates how to get started with the CDPLogger Client in both **N
 
 ## Documentation
 
-For documentation on the JS logger see [DOCUMENTATION.md](DOCUMENTATION.md)
+For documentation on the JS logger client see [DOCUMENTATION.md](DOCUMENTATION.md)
 
 ## Overview
 
@@ -14,14 +14,14 @@ For documentation on the JS logger see [DOCUMENTATION.md](DOCUMENTATION.md)
   - Requires a WebSocket polyfill (such as the `ws` package) since Node.js lacks a native WebSocket.
 
 - **Browser Version:**
-  - Uses the browser’s native WebSocket.
+  - Uses the browser's native WebSocket.
   - Obtains protobuf definitions from the global scope via `window.root` (set by including `containerPb.js`).
 
 ## Installation
 
 ### For Node.js
 
-Install the CDPLogger Client and a WebSocket polyfill:
+Install the CDPLogger Client and a WebSocket polyfill (for the Node.js version):
 
 ```bash
 npm install cdp-logger-client ws
@@ -38,7 +38,7 @@ Include the following scripts in your HTML:
 
 To enable web support, ensure your `client.js` file includes these modifications:
 
-1. **Use the Browser’s Native WebSocket:**  
+1. **Use the Browser's Native WebSocket:**  
    In the web version, remove or comment out any code that requires a WebSocket polyfill. For example:
    ```js
    // const WebSocket = require('ws'); // Do not use this in the browser
@@ -78,16 +78,33 @@ global.WebSocket = require('ws');
 // Create a client instance (endpoint can be "127.0.0.1:17000" or "ws://127.0.0.1:17000")
 const client = new cdplogger.Client('127.0.0.1:17000');
 
-// Fetch the API version from the CDP Logger
-client.requestApiVersion().then(version => {
-  console.log("CDP Logger API Version:", version);
-});
-
 // List logged nodes (displaying name and routing information)
 client.requestLoggedNodes().then(nodes => {
   nodes.forEach(node => {
     console.log(`Name: ${node.name}, Routing: ${node.routing}`);
   });
+  
+  // If we have nodes, request data points for the first one
+  if (nodes.length > 0) {
+    const nodeName = nodes[0].name;
+    console.log(`\nRequesting data points for node: ${nodeName}`);
+    
+    // Get log limits and request data points
+    client.requestLogLimits().then(limits => {
+      return client.requestDataPoints([nodeName], limits.startS, limits.endS, 10, 0);
+    }).then(dataPoints => {
+      console.log(`\nReceived ${dataPoints.length} data points:`);
+      dataPoints.forEach(point => {
+        console.log(`Timestamp: ${new Date(point.timestamp * 1000).toISOString()}`);
+        if (point.value && point.value[nodeName]) {
+          const val = point.value[nodeName];
+          console.log(`  Min: ${val.min}, Max: ${val.max}, Last: ${val.last}`);
+        }
+      });
+    }).catch(err => {
+      console.error("Error retrieving data points:", err);
+    });
+  }
 });
 
 // Disconnect after a short delay (for demonstration purposes)
@@ -119,25 +136,43 @@ Create an HTML file that includes the necessary scripts. For example:
   <body>
     <script>
       // The client is now available globally as "cdplogger" (attached to window)
-      const client = new cdplogger.Client("ws://127.0.0.1:17000");
-
-      // Fetch the API version from the CDP Logger and log it
-      client.requestApiVersion().then(version => {
-        console.log("CDP Logger API Version:", version);
-      });
+      // Use window.location.hostname to connect to the same host as the web page
+      const client = new cdplogger.Client(window.location.hostname + ":17000");
 
       // List logged nodes and output their names and routings
       client.requestLoggedNodes().then(nodes => {
         nodes.forEach(node => {
           console.log(`Name: ${node.name}, Routing: ${node.routing}`);
         });
+        
+        // If we have nodes, request data points for the first one
+        if (nodes.length > 0) {
+          const nodeName = nodes[0].name;
+          console.log(`\nRequesting data points for node: ${nodeName}`);
+          
+          // Get log limits and request data points
+          client.requestLogLimits().then(limits => {
+            return client.requestDataPoints([nodeName], limits.startS, limits.endS, 10, 0);
+          }).then(dataPoints => {
+            console.log(`\nReceived ${dataPoints.length} data points:`);
+            dataPoints.forEach(point => {
+              console.log(`Timestamp: ${new Date(point.timestamp * 1000).toISOString()}`);
+              if (point.value && point.value[nodeName]) {
+                const val = point.value[nodeName];
+                console.log(`  Min: ${val.min}, Max: ${val.max}, Last: ${val.last}`);
+              }
+            });
+          }).catch(err => {
+            console.error("Error retrieving data points:", err);
+          });
+        }
       });
     </script>
   </body>
 </html>
 ```
 
-*In the browser version, by including `client.js` (with the modifications described above), the client automatically uses the native WebSocket, the global protobuf definitions from `window.root`, and attaches the API to `window.cdplogger`.*
+*In the browser version, we use `window.location.hostname` to connect to the same host as the web page, with the default logger port 17000.*
 
 ## Prerequisites
 

README.md

@@ -1,7 +1,7 @@
 # CDPLogger Client for JavaScript
 
 A simple JavaScript interface for communicating with CDP applications that include a CDPLogger component to retrieve historic data. 
-- For documentation on the JS logger see [DOCUMENTATION.md](DOCUMENTATION.md).
+- For documentation on the JS logger client see [DOCUMENTATION.md](DOCUMENTATION.md).
 - For a quickstart guide on how to set-up the npm project for either Node or Web see [QUICKSTART.md](QUICKSTART.md)
 - For more information about CDP Studio see https://cdpstudio.com/.