Put Job API

The Put Job API can be used to create a new machine learning job in the cluster. The API accepts a PutJobRequest object as a request and returns a PutJobResponse.

Put Job Request

A PutJobRequest requires the following argument:

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

The configuration of the machine learning job to create as a Job

Job Configuration

The Job object contains all the details about the machine learning 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 job ID

An analysis configuration

A data description

Optionally, a human-readable description

Analysis Configuration

The analysis configuration of the machine learning 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");               

The function to use

The field to apply the function to

Optionally, a human-readable description

Then the same configuration would be:

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

Create a list of detectors

Pass the list of detectors to the analysis config builder constructor

The bucket span

Data Description

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");  

The time field

Synchronous Execution

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.

Asynchronous Execution

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 PutJobRequest to execute and the ActionListener to use when the execution completes

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) {
        
    }
};

Called when the execution is successfully completed.

Called when the whole PutJobRequest fails.

Response

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(); 

The creation time is a field that was not passed in the Job object in the request