LAMbot Configuration

Every instance of a LAMbot calls the onLoad function at startup. We recommend setting up shared values or lookup tables in the onLoad function. You can use it to initalize internal variables, load external JavaScript modules and set up structures needed for the filter function. For example:

var config = MooBot.loadModule('Config');
var moogUrl;

function onLoad() 
{
    var servletsConf = config.getConfig('servlets.conf');
        if (servletsConf) 
        {
        moogUrl = servletsConf.webhost;
        }
}

The onLoad function:

The LAMbot calls the presend function every time it assembles an object to publish on the Message Bus. Moogfarmd processes objects and turns them into alerts and Situations. An example presend function is:

function presend(event)
{
        event.setCustomInfoValue("eventDetails",overflow);
        if (overflow.LamInstanceName && (overflow.LamInstanceName === "DATA_SOURCE"))
        {
        delete overflow.LamInstanceName;
    }
        event.setCustomInfoValue("nodeSeverity", overflow.Severity);
    event.setCustomInfoValue("nodeMachineType", overflow.MachineType);
    event.setCustomInfoValue("nodeVendor", overflow.Vendor);
    return true;
}

The presend function:

You can partition event streams into substreams for differential processing in a distributed environment. You can send a boolean response if the configuration dictates that all objects will or will not be sent to the bus.

Instead of a boolean response, you can configure the function to return a JSON object containing two members: "passed" which is either true or false, and "stream" which defines the substream to send the event. For example:

function presend(event)
{
    return 
    ({
        "stream" : "my_stream",
        "passed" : true
    });
}

You can configure the event inside the presend function. For example you can:

In the LAMbot, the following line instructs the LAM to use the presend function. It calls filterFunction using the global LamBot variable:

LamBot.filterFunction("presend");

The filterFunction function receives a string, which is the name of the function to use for filtering.

You define the presend processing file or stream in individual LAM configuration files. See "Filtering" in Tokenize Source Event Data for more information.

REST Client-based LAMbots call preClientSend before they send a request to a polled server. The function accepts an object and returns a modified version that is then sent by the Rest Client LAM. An example preClientSend function is:

function preClientSend(outBoundEvent)
{
    outBoundEvent.set('method', 'Post');
    var header = outBoundEvent.value('header');
    header['Content-Type'] = 'application/json';
    outBoundEvent.set('header', header);
    var body = { 'events': 'all', 'type': { 'id': '12345', 'name': 'incident' } };
    outBoundEvent.set('body', body);
    return true;
}

The function generates a POST request with body type JSON.

In the LAMbot, the following line instructs the LAM to use the preClientSend function. It calls preClientSendFunction using the global LamBot variable:

LamBot.preClientSendFunction("preClientSend");

You can modify the response sent by a REST-based LAMbot after it receives an object and a REST Client-based LAMbot after it receives a response from a polled server. An example modifyResponse function is:

function modifyResponse(inBoundEventData)
{
    var response = JSON.parse(inBoundEventData.value('responseData'));
    if (inBoundEventData.value('moog_target_name') == 'target1') {
        response['manager'] = 'primary';
    }
    else {
        response['manager'] = 'secondary';
    }
    inBoundEventData.set('responseData', JSON.stringify(response));
    return true;
}

The function generates a different response depending on the name of the REST client target called.

In the LAMbot, the following line instructs the LAM to use the modifyResponse function. It calls modifyResponseFunction using the global LamBot variable:

LamBot.modifyResponseFunction("modifyResponse");