### Chained Zabbix Item Addition and Sending in Node.js

Source: https://github.com/shamil/node-zabbix-sender/blob/master/README.md

Illustrates the chaining capability of the `addItem` method, allowing an item to be added and sent in a single, fluent operation. This example sends a single item and processes the response. Requires the 'node-zabbix-sender' module.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var Sender = new ZabbixSender({host: 'zabbix.example.com'});

// addItem supports chaining
// Here is an example: add item and & send it
Sender.addItem('cpu_load', 0.15).send(function(err, res) {
    if (err) {
        throw err;
    }

    // print the response object
    console.dir(res);
});
```

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

### Implement Error Handling and Retry Logic with Zabbix Sender

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Provides a robust example of error handling and implementing a retry mechanism for sending data to Zabbix. It configures connection parameters like host, port, and timeout, and uses a recursive `setTimeout` function to retry sends on failure. Requires the 'node-zabbix-sender' package.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var sender = new ZabbixSender({
    host: 'zabbix.example.com',
    port: 10051,
    timeout: 3000  // 3 second timeout
});

function sendWithRetry(maxRetries) {
    var attempts = 0;

    sender.addItem('app.status', 'running');
    sender.addItem('app.uptime', 3600);

    function attemptSend() {
        attempts++;
        console.log('Attempt', attempts, 'of', maxRetries);

        sender.send(function(err, response, items) {
            if (err) {
                console.error('Send failed:', err.message);

                if (attempts < maxRetries) {
                    console.log('Retrying in 5 seconds...');
                    setTimeout(attemptSend, 5000);
                } else {
                    console.error('Max retries reached. Items lost:', items);
                }
                return;
            }

            console.log('Success:', response.info);
            console.log('Processed', items.length, 'items');
        });
    }

    attemptSend();
}

sendWithRetry(3);
```

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

### Basic Zabbix Item Sending with Node.js

Source: https://github.com/shamil/node-zabbix-sender/blob/master/README.md

Demonstrates how to initialize the Zabbix sender, add items with hosts, and send them to the Zabbix server. It handles potential errors and logs the server response. Requires the 'node-zabbix-sender' module.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var Sender = new ZabbixSender({host: 'zabbix.example.com'});

// Add items to request
Sender.addItem('webserver', 'httpd.running', 0);
Sender.addItem('dbserver', 'mysql.ping', 1);

// Add item with default host
Sender.addItem('httpd.logs.size', 1024);

// Send the items to zabbix trapper
Sender.send(function(err, res) {
    if (err) {
        throw err;
    }

    // print the response object
    console.dir(res);
});
```

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

### Initialize ZabbixSender Instance in Node.js

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Initializes a ZabbixSender instance to connect to a Zabbix server. Supports basic and full configurations including host, port, timeout, timestamp inclusion (with nanosecond precision), and default item host.

```javascript
var ZabbixSender = require('node-zabbix-sender');

// Basic initialization with default options
var sender = new ZabbixSender();

// Full configuration with all options
var sender = new ZabbixSender({
    host: 'zabbix.example.com',     // Zabbix server hostname or IP
    port: 10051,                     // Zabbix trapper port (default: 10051)
    timeout: 5000,                   // Socket timeout in milliseconds (default: 5000)
    with_timestamps: true,           // Include timestamps with items (default: false)
    with_ns: true,                   // Include nanosecond precision (default: false)
    items_host: 'my-app-server'      // Default host for items (default: os.hostname())
});
```

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

### Node.js Zabbix Sender Default Instance Options

Source: https://github.com/shamil/node-zabbix-sender/blob/master/README.md

Presents the default configuration options for creating a ZabbixSender instance. These options control the Zabbix server connection (host, port, timeout) and item data formatting (timestamps, nanoseconds, default host).

```javascript
{
    host: 'localhost',
    port: 10051,
    timeout: 5000,
    with_ns: false,
    with_timestamps: false,
    items_host: require('os').hostname()
}
```

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

### Batch Monitoring for Multiple Hosts with Zabbix Sender

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Demonstrates how to collect and send monitoring data for multiple hosts and services in a single batch operation. This efficient approach is ideal for large environments, reducing network overhead and simplifying data collection. Requires the 'node-zabbix-sender' package.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var sender = new ZabbixSender({
    host: 'zabbix.example.com',
    timeout: 10000
});

// Collect metrics from multiple servers
var servers = [
    { hostname: 'web1', cpu: 0.45, memory: 2048, connections: 150 },
    { hostname: 'web2', cpu: 0.62, memory: 3072, connections: 220 },
    { hostname: 'db1', cpu: 0.88, memory: 8192, connections: 45 }
];

// Add all metrics to sender
servers.forEach(function(server) {
    sender.addItem(server.hostname, 'system.cpu.load', server.cpu);
    sender.addItem(server.hostname, 'system.memory.used', server.memory);
    sender.addItem(server.hostname, 'net.connections', server.connections);
});

console.log('Total metrics to send:', sender.countItems()); // Output: 9

// Send all metrics in one batch
sender.send(function(err, response, items) {
    if (err) {
        console.error('Batch send failed:', err.message);
        return;
    }

    console.log('Batch send complete');
    console.log('Server response:', response.info);
    // Example: "processed: 9; failed: 0; total: 9; seconds spent: 0.000123"
});
```

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

### Enable Timestamps and Nanosecond Precision with Zabbix Sender

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Demonstrates how to enable timestamp support for monitoring data, including nanosecond precision. This ensures precise timing information is sent along with metrics, which is crucial for time-series analysis and accurate event correlation. Requires the 'node-zabbix-sender' package.

```javascript
var ZabbixSender = require('node-zabbix-sender');

// Enable timestamps only
var senderWithTimestamps = new ZabbixSender({
    host: 'zabbix.example.com',
    with_timestamps: true
});

senderWithTimestamps.addItem('app.event', 'user_login');
// Item will include: { host: '...', key: 'app.event', value: 'user_login', clock: 1702645200 }

// Enable nanosecond precision (implies with_timestamps: true)
var senderWithNs = new ZabbixSender({
    host: 'zabbix.example.com',
    with_ns: true
});

senderWithNs.addItem('response.time', 0.125);
// Item will include: { host: '...', key: 'response.time', value: 0.125, clock: 1702645200, ns: 500000000 }

senderWithNs.send(function(err, response, items) {
    if (err) throw err;
    console.log('Sent items with timestamps:', items);
    // Each item includes clock and ns fields for precise timing
});
```

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

### Add Monitoring Items to Queue in Node.js

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Adds monitoring items to the send queue using the `addItem` method. Supports explicit host specification for each item or uses a default host configured during initialization. Method chaining is also supported for adding multiple items sequentially. Returns the current number of queued items.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var sender = new ZabbixSender({
    host: 'zabbix.example.com',
    items_host: 'default-host'
});

// Add item with explicit host
sender.addItem('webserver', 'httpd.running', 0);
sender.addItem('dbserver', 'mysql.ping', 1);
sender.addItem('appserver', 'app.memory.usage', 2048);

// Add item using default host (items_host)
sender.addItem('cpu.load', 0.75);
sender.addItem('disk.free', 1024000);

// Method chaining is supported
sender
    .addItem('server1', 'cpu.temp', 65)
    .addItem('server1', 'disk.io', 150)
    .addItem('network.bandwidth', 1000);

console.log('Items queued:', sender.countItems()); // Output: Items queued: 8
```

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

### Chained addItem and send Operations in Node.js

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Demonstrates chaining `addItem` calls with the `send` method for fluent and concise operations. This allows adding one or more items and immediately sending them to the Zabbix server in a single chain, improving code readability.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var sender = new ZabbixSender({host: 'zabbix.example.com'});

// Add single item and immediately send
sender
    .addItem('cpu_load', 0.15)
    .send(function(err, response) {
        if (err) {
            console.error('Send failed:', err.message);
            return;
        }
        console.log('CPU load sent successfully');
        console.dir(response);
    });

// Multiple items with chaining
sender
    .addItem('memory.used', 4096)
    .addItem('memory.free', 8192)
    .addItem('swap.used', 512)
    .send(function(err, response) {
        if (err) throw err;
        console.log('Memory metrics sent:', response.info);
    });
```

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

### Count Pending Items Method in Zabbix Sender

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Illustrates the usage of the `countItems` method to retrieve the current number of monitoring data points queued for sending. This method is helpful for managing the queue size and deciding when to send data, or for debugging. Requires the 'node-zabbix-sender' package.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var sender = new ZabbixSender({host: 'zabbix.example.com'});

console.log('Initial count:', sender.countItems()); // Output: 0

sender.addItem('metric1', 10);
sender.addItem('metric2', 20);
sender.addItem('metric3', 30);

var count = sender.countItems();
console.log('Pending items:', count); // Output: 3

if (count > 0) {
    sender.send(function(err, response) {
        if (err) throw err;
        console.log('Sent', count, 'items');
        console.log('Items after send:', sender.countItems()); // Output: 0 (cleared after successful send)
    });
}
```

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

### Send Queued Items to Zabbix Server in Node.js

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Sends all currently queued items to the Zabbix server using the `send` method. It accepts a callback function that receives an error object, the Zabbix server response, and the list of items that were sent. If an error occurs, items are retained for potential retry.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var sender = new ZabbixSender({host: 'zabbix.example.com'});

sender.addItem('webserver', 'httpd.running', 1);
sender.addItem('webserver', 'httpd.requests', 5420);
sender.addItem('dbserver', 'mysql.queries', 8932);

sender.send(function(err, response, items) {
    if (err) {
        console.error('Error sending to Zabbix:', err.message);
        console.log('Items will be retained for retry');
        return;
    }

    // Response from Zabbix server
    console.log('Response:', response);
    // Example output: { response: 'success', info: 'processed: 3; failed: 0; total: 3; seconds spent: 0.000050' }

    // Items that were sent
    console.log('Sent items:', items);
    // Example output: [
    //   { host: 'webserver', key: 'httpd.running', value: 1 },
    //   { host: 'webserver', key: 'httpd.requests', value: 5420 },
    //   { host: 'dbserver', key: 'mysql.queries', value: 8932 }
    // ]
});
```

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

### Clear Pending Items Method in Zabbix Sender

Source: https://context7.com/shamil/node-zabbix-sender/llms.txt

Shows how to use the `clearItems` method to manually remove all queued monitoring data before it is sent. This is useful for discarding metrics based on certain conditions, preventing unnecessary data transmission. Requires the 'node-zabbix-sender' package.

```javascript
var ZabbixSender = require('node-zabbix-sender');
var sender = new ZabbixSender({host: 'zabbix.example.com'});

sender.addItem('test.metric1', 100);
sender.addItem('test.metric2', 200);
sender.addItem('test.metric3', 300);

console.log('Items before clear:', sender.countItems()); // Output: 3

sender.clearItems();

console.log('Items after clear:', sender.countItems());  // Output: 0

// Useful for conditional sending
if (someCondition) {
    sender.send(callback);
} else {
    sender.clearItems(); // Discard metrics if condition not met
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.