Put anomaly detection job API

A PutJobRequest requires the following argument:

PutJobRequest request = new PutJobRequest(jobBuilder.build()); 

The Job object contains all the details about the anomaly detection job configuration.

A Job requires the following arguments:

Job.Builder jobBuilder = new Job.Builder(id)      
    .setAnalysisConfig(analysisConfigBuilder)     
    .setDataDescription(dataDescriptionBuilder)   
    .setDescription("Total sum of requests");     

The analysis configuration of the anomaly detection job is defined in the AnalysisConfig. AnalysisConfig reflects all the configuration settings that can be defined using the REST API.

Using the REST API, we could define this analysis configuration:

"analysis_config" : {
  "bucket_span" : "10m",
  "detectors" : [
    {
      "detector_description" : "Sum of total",
      "function" : "sum",
      "field_name" : "total"
    }
  ]
}

Using the AnalysisConfig object and the high level REST client, the list of detectors must be built first.

An example of building a Detector instance is as follows:

Detector.Builder detectorBuilder = new Detector.Builder()
    .setFunction("sum")                                    
    .setFieldName("total")                                 
    .setDetectorDescription("Sum of total");               

Then the same configuration would be:

List<Detector> detectors = Collections.singletonList(detectorBuilder.build());       
AnalysisConfig.Builder analysisConfigBuilder = new AnalysisConfig.Builder(detectors) 
    .setBucketSpan(TimeValue.timeValueMinutes(10));                                  

After defining the analysis config, the next thing to define is the data description, using a DataDescription instance. DataDescription reflects all the configuration settings that can be defined using the REST API.

Using the REST API, we could define this metrics configuration:

"data_description" : {
  "time_field" : "timestamp"
}

Using the DataDescription object and the high level REST client, the same configuration would be:

DataDescription.Builder dataDescriptionBuilder = new DataDescription.Builder()
    .setTimeField("timestamp");  

When executing a PutJobRequest in the following manner, the client waits for the PutJobResponse to be returned before continuing with code execution:

PutJobResponse response = client.machineLearning().putJob(request, RequestOptions.DEFAULT);

Synchronous calls may throw an IOException in case of either failing to parse the REST response in the high-level REST client, the request times out or similar cases where there is no response coming back from the server.

In cases where the server returns a 4xx or 5xx error code, the high-level client tries to parse the response body error details instead and then throws a generic ElasticsearchException and adds the original ResponseException as a suppressed exception to it.

Executing a PutJobRequest can also be done in an asynchronous fashion so that the client can return directly. Users need to specify how the response or potential failures will be handled by passing the request and a listener to the asynchronous put-job method:

client.machineLearning().putJobAsync(request, RequestOptions.DEFAULT, listener); 

The asynchronous method does not block and returns immediately. Once it is completed the ActionListener is called back using the onResponse method if the execution successfully completed or using the onFailure method if it failed. Failure scenarios and expected exceptions are the same as in the synchronous execution case.

A typical listener for put-job looks like:

ActionListener<PutJobResponse> listener = new ActionListener<PutJobResponse>() {
    @Override
    public void onResponse(PutJobResponse response) {
        
    }

    @Override
    public void onFailure(Exception e) {
        
    }
};

The returned PutJobResponse returns the full representation of the new machine learning job if it has been successfully created. This will contain the creation time and other fields initialized using default values:

Date createTime = response.getResponse().getCreateTime();