This documentation contains work-in-progress information for future Elastic Stack and Cloud releases. Use the version selector to view supported release docs. It also contains some Elastic Cloud serverless information. Check out our serverless docs for more details.

› › ›

Get Watcher stats API

edit

Get Watcher stats API

edit

Retrieves the current Watcher metrics.

Request

edit

GET _watcher/stats

GET _watcher/stats/<metric>

Prerequisites

edit

You must have manage_watcher or monitor_watcher cluster privileges to use this API. For more information, see Security privileges.

Path parameters

edit

emit_stacktraces

(Optional, Boolean) Defines whether stack traces are generated for each watch that is running. The default value is false.

<metric>

(Optional, enum) Defines which additional metrics are included in the response.

current_watches: Includes the current executing watches in the response.
queued_watches: Includes the watches queued for execution in the response.
_all: Includes all metrics in the response.

Response body

edit

This API always returns basic metrics. You retrieve more metrics by using the metric parameter.

current_watches

(list) The current executing watches metric gives insight into the watches that are currently being executed by Watcher. Additional information is shared per watch that is currently executing. This information includes the watch_id, the time its execution started and its current execution phase.

To include this metric, the `metric` option should be set to `current_watches`
or `_all`. In addition you can also specify the `emit_stacktraces=true`
parameter, which adds stack traces for each watch that is being executed. These
stack traces can give you more insight into an execution of a watch.

queued_watches

(list) Watcher moderates the execution of watches such that their execution won’t put too much pressure on the node and its resources. If too many watches trigger concurrently and there isn’t enough capacity to execute them all, some of the watches are queued, waiting for the current executing watches to finish their execution. The queued watches metric gives insight on these queued watches.

To include this metric, the `metric` option should include `queued_watches` or
`_all`.

Examples

edit

The following example calls the stats API to retrieve basic metrics:

resp = client.watcher.stats()
print(resp)

response = client.watcher.stats
puts response

const response = await client.watcher.stats();
console.log(response);

GET _watcher/stats

A successful call returns a JSON structure similar to the following example:

{
   "watcher_state": "started",  
   "watch_count": 1, 
   "execution_thread_pool": {
      "size": 1000, 
      "max_size": 1 
   }
}

	The current state of watcher, which can be `started`, `starting`, or `stopped`.
	The number of watches currently registered.
	The number of watches that were triggered and currently queued for execution.
	The largest size of the execution thread pool, which indicates the largest number of concurrent executing watches.

The following example specifies the metric option as a query string argument and will include the basic metrics and metrics about the current executing watches:

resp = client.watcher.stats(
    metric="current_watches",
)
print(resp)

response = client.watcher.stats(
  metric: 'current_watches'
)
puts response

const response = await client.watcher.stats({
  metric: "current_watches",
});
console.log(response);

GET _watcher/stats?metric=current_watches

The following example specifies the metric option as part of the url path:

resp = client.watcher.stats(
    metric="current_watches",
)
print(resp)

response = client.watcher.stats(
  metric: 'current_watches'
)
puts response

const response = await client.watcher.stats({
  metric: "current_watches",
});
console.log(response);

GET _watcher/stats/current_watches

The following snippet shows an example of a successful JSON response that captures a watch in execution:

{
   "watcher_state": "started",
   "watch_count": 2,
   "execution_thread_pool": {
      "queue_size": 1000,
      "max_size": 20
   },
   "current_watches": [ 
      {
         "watch_id": "slow_condition", 
         "watch_record_id": "slow_condition_3-2015-05-13T07:42:32.179Z", 
         "triggered_time": "2015-05-12T11:53:51.800Z", 
         "execution_time": "2015-05-13T07:42:32.179Z", 
         "execution_phase": "condition" 
      }
   ]
}

	A list of all the watches that are currently being executed by Watcher. When no watches are currently executing, an empty array is returned. The captured watches are sorted by execution time in descending order. Thus the longest running watch is always at the top.
	The id of the watch being executed.
	The id of the watch record.
	The time the watch was triggered by the trigger engine.
	The time the watch was executed. This is just before the input is being executed.
	The current watch execution phase. Can be `input`, `condition` `actions`, `awaits_execution`, `started`, `watch_transform`, `aborted`, `finished`.

The following example specifies the queued_watches metric option and includes both the basic metrics and the queued watches:

resp = client.watcher.stats(
    metric="queued_watches",
)
print(resp)

response = client.watcher.stats(
  metric: 'queued_watches'
)
puts response

const response = await client.watcher.stats({
  metric: "queued_watches",
});
console.log(response);

GET _watcher/stats/queued_watches

An example of a successful JSON response that captures a watch in execution:

{
   "watcher_state": "started",
   "watch_count": 10,
   "execution_thread_pool": {
      "queue_size": 1000,
      "max_size": 20
   },
   "queued_watches": [ 
         {
            "watch_id": "slow_condition4", 
            "watch_record_id": "slow_condition4_223-2015-05-21T11:59:59.811Z", 
            "triggered_time": "2015-05-21T11:59:59.811Z", 
            "execution_time": "2015-05-21T11:59:59.811Z" 
         },
      ...
   ]
}

	A list of all watches that are currently queued for execution. When no watches are queued, an empty array is returned.
	The id of the watch queued for execution.
	The id of the watch record.
	The time the watch was triggered by the trigger engine.
	The time the watch was went into a queued state.

« Get watch API Query watches API »