Converse agora com nosso suporte
Chat com o suporte

Foglight 7.1.0 - Web Component Tutorial

Introducing the Web Component Framework The Web Component Framework Configuring Views and Context Queries Functions Bindings Additional Components

Performance Improvements

This contains information that can help you improve the performance of your dashboards.

Optimizing Data Access with the Batch API

Batch data access results in optimized data access through single back-end round trips. This is highly advisable for dashboards that load more than a handful of metrics.

For example, you may have a dashboard showing thousands of hosts and their metrics in a table. Populating these metric values can results in numerous back-end round-trips, which affects the table performance when any of the following actions are performed:

•
Sorting a column that points to a metric
•
Viewing the table if an initial sort is defined for one of the columns
•
Calculating a maximum column value
•
Searching the table

First, you need to write a function that triggers the Batch API mode. The batch data access API is exposed on the Data Service through the following APIs:

/**
* Returns a new query object that can be configured to specify the data that is
* to be returned.
* @return the blank query object
*/
ObservationQuery createObservationQuery();
/**
* Performs the query specified in the query object and returns the resulting data.
* @param query the query to perform
* @return the queried data
*/
ObservationQueryResult performQuery(ObservationQuery query);

The ObservationQuery interface includes methods to set the time range, retrieve observations, and the retrieval type. When used from WCF, the start and end times of the time range are set based on the SpecificTimeRange object provided by WCF. If the metrics are used in chart components, a SpecificTimeRange object for charts can be obtained by calling the method functionHelper.getSpecificTimeRangeForCharting().

 
* 
NOTE: Any metrics used by the dashboard implementing the Batch API mode need to be added to the set of observations that are to be retrieved. There are no restrictions on which observation keys can be added to the set: they can be obtained from different topology objects, and can be of different types (such as Metrics, StringObservations, and so on). The retrieval type defines the type of data access. If the view is displaying current and period values, then the retrieval type should be AGGREGATE_AND_LAST (the default). The other options are AGGREGATE, if only the period value is required, LAST_N if only the current value is required, or RAW if raw metric values are required.

The following Groovy script has an example of how you can call the batch API. The results of the batch data access call are not important for the observation pre-loading to work, and can be discarded by the Groovy script. WCF is not aware of batch queries and the dashboards will continue to access the observations in the usual way, but that access will not require any database round trips because the observations will be in the Persistence Cache after the batch loading script completes.

import com.quest.nitro.service.sl.interfaces.data.IDataService;
import com.quest.nitro.service.sl.interfaces.data.ObservationQuery;
import com.quest.nitro.model.topology.TopologyObject;
import com.quest.nitro.service.sl.ServiceLocatorFactory;
import org.apache.log4j.Logger;
 
def LOG = Logger.getLogger("batch.query.test");
topologyObjects = new HashSet(#! RequestType #.topologyObjects);
LOG.info("Querying ${topologyObjects.size()} topology objects...");
 
endTime = System.currentTimeMillis();
startTime = endTime - (4 * 60 * 60 * 1000L);
 
IDataService dataSvc = ServiceLocatorFactory.getLocator().getDataService();
ObservationQuery query = dataSvc.createObservationQuery();
query.setStartTime(startTime);
query.setEndTime(endTime);
query.include(topologyObjects, "responseTime");
query.include(topologyObjects, "invocations");
result = dataSvc.performQuery(query);
 
long duration = System.currentTimeMillis() - endTime;
LOG.info("Query completed in ${duration} ms.");

Next, in WCF, to enter the Batch API mode, invoke that function by using the Prepare For Inspection property.

Figure 61. Prepare For Inspection property

The Tree Table and Row-Oriented Table components include this property. The calling component does not take into consideration the result of this function, so as long as you call the function this way, it starts the Batch API mode.

For example, a dashboard can list thousands of hosts, including their names and different metrics (for example, Metric A, B and C). This data displays in columns of a Row-Oriented Table component. If Metric B is more important than metrics A and C, so the user should be able to sort this column or search for a specific value. The layout cannot display all of the rows, so for example, it only shows 20 rows. If the end-user attempts to sort the column containing Metric B, that sort will not be very fast because it requires a round-trip to server to get that value for each host.

To overcome this problem, the function you write to start the Batch API mode can take a list of topology objects (hosts) and the Metric B name as inputs. For example:

import com.quest.nitro.service.sl.interfaces.data.IDataService;
import com.quest.nitro.service.sl.interfaces.data.ObservationQuery;
import com.quest.nitro.model.topology.TopologyObject;
import com.quest.nitro.service.sl.ServiceLocatorFactory;
import org.apache.log4j.Logger;
topologyObjects = args["topologyObjects"]
metricName = args["metricName"]
IDataService dataSvc = ServiceLocatorFactory.getLocator().getDataService();
ObservationQuery query = dataSvc.createObservationQuery();
query.setStartTime(specificTimeRange.getStart().getTime());
query.setEndTime(specificTimeRange.getEnd().getTime());
query.include(new HashSet<TopologyObject>(topologyObjects), metricName);
dataSvc.performQuery(query);
return true;

At run-time when the table is rendered, if the user sort the column that contains Metric B, this function is invoked and the Batching API mode starts. Row objects with all instances of Metric B (one for each host) are cached, which eliminates the need for subsequent round trips to the server to retrieve individual Metric B values. If you want to apply this behavior to Metric A and Metric C, invoke the function for each column.

 

Documentos relacionados

The document was helpful.

Selecione a classificação

I easily found the information I needed.

Selecione a classificação