866 lines
18 KiB
Markdown
866 lines
18 KiB
Markdown
---
|
|
title: WindowNode
|
|
description: WindowNode caches data within a moving time range.
|
|
note: Auto generated by tickdoc
|
|
|
|
menu:
|
|
kapacitor_1_6_ref:
|
|
name: WindowNode
|
|
identifier: window_node
|
|
weight: 100
|
|
parent: nodes
|
|
---
|
|
|
|
The `window` node caches data within a moving time range.
|
|
The `period` property of `window` defines the time range covered by `window`.
|
|
|
|
The `every` property of `window` defines the frequency at which the window
|
|
is emitted to the next node in the pipeline.
|
|
|
|
The `align` property of `window` defines how to align the window edges.
|
|
(By default, the edges are defined relative to the first data point the `window`
|
|
node receives.)
|
|
|
|
Example:
|
|
|
|
|
|
```js
|
|
stream
|
|
|window()
|
|
.period(10m)
|
|
.every(5m)
|
|
|httpOut('recent')
|
|
```
|
|
|
|
This example emits the last `10 minute` period every `5 minutes` to the pipeline's `httpOut` node.
|
|
Because `every` is less than `period`, each time the window is emitted it contains `5 minutes` of
|
|
new data and `5 minutes` of the previous period's data.
|
|
|
|
{{% note %}}
|
|
**NOTE:** Because no `align` property is defined, the `window` edge is defined relative to the first data point.
|
|
{{% /note %}}
|
|
|
|
### Constructor
|
|
|
|
| Chaining Method | Description |
|
|
|:---------|:---------|
|
|
| **window ( )** | Create a new node that windows the stream by time. |
|
|
|
|
### Property Methods
|
|
|
|
| Setters | Description |
|
|
|:---|:---|
|
|
| **[align](#align) ( )** | If the `align` property is not used to modify the `window` node, then the window alignment is assumed to start at the time of the first data point it receives. If `align` property is set, the window time edges will be truncated to the `every` property (For example, if a data point's time is 12:06 and the `every` property is `5m` then the data point's window will range from 12:05 to 12:10). |
|
|
| **[every](#every) ( `value` `time.Duration`)** | How often the current window is emitted into the pipeline. If equal to zero, then every new point will emit the current window. |
|
|
| **[everyCount](#everycount) ( `value` `int64`)** | EveryCount determines how often the window is emitted based on the count of points. A value of 1 means that every new point will emit the window. |
|
|
| **[fillPeriod](#fillperiod) ( )** | FillPeriod instructs the WindowNode to wait till the period has elapsed before emitting the first batch. This only applies if the period is greater than the every value. |
|
|
| **[period](#period) ( `value` `time.Duration`)** | The period, or length in time, of the window. |
|
|
| **[periodCount](#periodcount) ( `value` `int64`)** | PeriodCount is the number of points per window. |
|
|
| **[quiet](#quiet) ( )** | Suppress all error logging events from this node. |
|
|
|
|
|
|
|
|
### Chaining Methods
|
|
[Alert](#alert),
|
|
[Barrier](#barrier),
|
|
[Bottom](#bottom),
|
|
[ChangeDetect](#changedetect),
|
|
[Combine](#combine),
|
|
[Count](#count),
|
|
[CumulativeSum](#cumulativesum),
|
|
[Deadman](#deadman),
|
|
[Default](#default),
|
|
[Delete](#delete),
|
|
[Derivative](#derivative),
|
|
[Difference](#difference),
|
|
[Distinct](#distinct),
|
|
[Ec2Autoscale](#ec2autoscale),
|
|
[Elapsed](#elapsed),
|
|
[Eval](#eval),
|
|
[First](#first),
|
|
[Flatten](#flatten),
|
|
[GroupBy](#groupby),
|
|
[HoltWinters](#holtwinters),
|
|
[HoltWintersWithFit](#holtwinterswithfit),
|
|
[HttpOut](#httpout),
|
|
[HttpPost](#httppost),
|
|
[InfluxDBOut](#influxdbout),
|
|
[Join](#join),
|
|
[K8sAutoscale](#k8sautoscale),
|
|
[KapacitorLoopback](#kapacitorloopback),
|
|
[Last](#last),
|
|
[Log](#log),
|
|
[Max](#max),
|
|
[Mean](#mean),
|
|
[Median](#median),
|
|
[Min](#min),
|
|
[Mode](#mode),
|
|
[MovingAverage](#movingaverage),
|
|
[Percentile](#percentile),
|
|
[Sample](#sample),
|
|
[Shift](#shift),
|
|
[Sideload](#sideload),
|
|
[Spread](#spread),
|
|
[StateCount](#statecount),
|
|
[StateDuration](#stateduration),
|
|
[Stats](#stats),
|
|
[Stddev](#stddev),
|
|
[Sum](#sum),
|
|
[SwarmAutoscale](#swarmautoscale),
|
|
[Top](#top),
|
|
[Trickle](#trickle),
|
|
[Union](#union),
|
|
[Where](#where),
|
|
[Window](#window)
|
|
|
|
---
|
|
|
|
## Properties
|
|
|
|
Property methods modify state on the calling node.
|
|
They do not add another node to the pipeline, and always return a reference to the calling node.
|
|
Property methods are marked using the `.` operator.
|
|
|
|
### Align
|
|
|
|
Set the `align` property to truncate the window time edges to the `every` property. For example, if a data point's time is 12:06 and the `every` property is `5m` then the data point's window ranges from 12:05 to 12:10).
|
|
|
|
If the `align` property isn't used to modify the `window` node, the window alignment starts at the time the first data point is received.
|
|
|
|
```js
|
|
window.align()
|
|
```
|
|
> Note: When ingesting data at irregular intervals, we recommend using `window.align()` to group data.
|
|
|
|
|
|
### Every
|
|
|
|
How often the current window is emitted into the pipeline.
|
|
If equal to zero, then every new point will emit the current window.
|
|
|
|
|
|
```js
|
|
window.every(value time.Duration)
|
|
```
|
|
|
|
|
|
### EveryCount
|
|
|
|
EveryCount determines how often the window is emitted based on the count of points.
|
|
A value of 1 means that every new point will emit the window.
|
|
|
|
|
|
```js
|
|
window.everyCount(value int64)
|
|
```
|
|
|
|
|
|
### FillPeriod
|
|
|
|
FillPeriod instructs the [WindowNode](/kapacitor/v1.6/nodes/window_node/) to wait till the period has elapsed before emitting the first batch.
|
|
This only applies if the period is greater than the every value.
|
|
|
|
|
|
```js
|
|
window.fillPeriod()
|
|
```
|
|
|
|
|
|
### Period
|
|
|
|
The period, or length in time, of the window.
|
|
|
|
|
|
```js
|
|
window.period(value time.Duration)
|
|
```
|
|
|
|
|
|
### PeriodCount
|
|
|
|
PeriodCount is the number of points per window.
|
|
|
|
|
|
```js
|
|
window.periodCount(value int64)
|
|
```
|
|
|
|
|
|
### Quiet
|
|
|
|
Suppress all error logging events from this node.
|
|
|
|
```js
|
|
window.quiet()
|
|
```
|
|
|
|
|
|
## Chaining Methods
|
|
|
|
Chaining methods create a new node in the pipeline as a child of the calling node.
|
|
They do not modify the calling node.
|
|
Chaining methods are marked using the `|` operator.
|
|
|
|
|
|
### Alert
|
|
|
|
Create an alert node, which can trigger alerts.
|
|
|
|
|
|
```js
|
|
window|alert()
|
|
```
|
|
|
|
Returns: [AlertNode](/kapacitor/v1.6/nodes/alert_node/)
|
|
|
|
### Barrier
|
|
|
|
Create a new Barrier node that emits a BarrierMessage periodically.
|
|
|
|
One BarrierMessage will be emitted every period duration.
|
|
|
|
|
|
```js
|
|
window|barrier()
|
|
```
|
|
|
|
Returns: [BarrierNode](/kapacitor/v1.6/nodes/barrier_node/)
|
|
|
|
### Bottom
|
|
|
|
Select the bottom `num` points for `field` and sort by any extra tags or fields.
|
|
|
|
|
|
```js
|
|
window|bottom(num int64, field string, fieldsAndTags ...string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### ChangeDetect
|
|
|
|
Create a new node that only emits new points if different from the previous point.
|
|
|
|
```js
|
|
window|changeDetect(field string)
|
|
```
|
|
|
|
Returns: [ChangeDetectNode](/kapacitor/v1.6/nodes/change_detect_node/)
|
|
|
|
### Combine
|
|
|
|
Combine this node with itself. The data is combined on timestamp.
|
|
|
|
|
|
```js
|
|
window|combine(expressions ...ast.LambdaNode)
|
|
```
|
|
|
|
Returns: [CombineNode](/kapacitor/v1.6/nodes/combine_node/)
|
|
|
|
### Count
|
|
|
|
Count the number of points.
|
|
|
|
|
|
```js
|
|
window|count(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### CumulativeSum
|
|
|
|
Compute a cumulative sum of each point that is received.
|
|
A point is emitted for every point collected.
|
|
|
|
|
|
```js
|
|
window|cumulativeSum(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Deadman
|
|
|
|
Helper function for creating an alert on low throughput, a.k.a. deadman's switch.
|
|
|
|
- Threshold: trigger alert if throughput drops below threshold in points/interval.
|
|
- Interval: how often to check the throughput.
|
|
- Expressions: optional list of expressions to also evaluate. Useful for time of day alerting.
|
|
|
|
Example:
|
|
|
|
|
|
```js
|
|
var data = stream
|
|
|from()...
|
|
// Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
|
|
data
|
|
|deadman(100.0, 10s)
|
|
//Do normal processing of data
|
|
data...
|
|
```
|
|
|
|
The above is equivalent to this example:
|
|
|
|
|
|
```js
|
|
var data = stream
|
|
|from()...
|
|
// Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
|
|
data
|
|
|stats(10s)
|
|
.align()
|
|
|derivative('emitted')
|
|
.unit(10s)
|
|
.nonNegative()
|
|
|alert()
|
|
.id('node \'stream0\' in task \'{{ .TaskName }}\'')
|
|
.message('{{ .ID }} is {{ if eq .Level "OK" }}alive{{ else }}dead{{ end }}: {{ index .Fields "emitted" | printf "%0.3f" }} points/10s.')
|
|
.crit(lambda: "emitted" <= 100.0)
|
|
//Do normal processing of data
|
|
data...
|
|
```
|
|
|
|
The `id` and `message` alert properties can be configured globally via the 'deadman' configuration section.
|
|
|
|
Since the [AlertNode](/kapacitor/v1.6/nodes/alert_node/) is the last piece it can be further modified as usual.
|
|
Example:
|
|
|
|
|
|
```js
|
|
var data = stream
|
|
|from()...
|
|
// Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
|
|
data
|
|
|deadman(100.0, 10s)
|
|
.slack()
|
|
.channel('#dead_tasks')
|
|
//Do normal processing of data
|
|
data...
|
|
```
|
|
|
|
You can specify additional lambda expressions to further constrain when the deadman's switch is triggered.
|
|
Example:
|
|
|
|
|
|
```js
|
|
var data = stream
|
|
|from()...
|
|
// Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
|
|
// Only trigger the alert if the time of day is between 8am-5pm.
|
|
data
|
|
|deadman(100.0, 10s, lambda: hour("time") >= 8 AND hour("time") <= 17)
|
|
//Do normal processing of data
|
|
data...
|
|
```
|
|
|
|
|
|
|
|
```js
|
|
window|deadman(threshold float64, interval time.Duration, expr ...ast.LambdaNode)
|
|
```
|
|
|
|
Returns: [AlertNode](/kapacitor/v1.6/nodes/alert_node/)
|
|
|
|
### Default
|
|
|
|
Create a node that can set defaults for missing tags or fields.
|
|
|
|
|
|
```js
|
|
window|default()
|
|
```
|
|
|
|
Returns: [DefaultNode](/kapacitor/v1.6/nodes/default_node/)
|
|
|
|
### Delete
|
|
|
|
Create a node that can delete tags or fields.
|
|
|
|
|
|
```js
|
|
window|delete()
|
|
```
|
|
|
|
Returns: [DeleteNode](/kapacitor/v1.6/nodes/delete_node/)
|
|
|
|
### Derivative
|
|
|
|
Create a new node that computes the derivative of adjacent points.
|
|
|
|
|
|
```js
|
|
window|derivative(field string)
|
|
```
|
|
|
|
Returns: [DerivativeNode](/kapacitor/v1.6/nodes/derivative_node/)
|
|
|
|
### Difference
|
|
|
|
Compute the difference between points independent of elapsed time.
|
|
|
|
|
|
```js
|
|
window|difference(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Distinct
|
|
|
|
Produce batch of only the distinct points.
|
|
|
|
|
|
```js
|
|
window|distinct(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Ec2Autoscale
|
|
|
|
Create a node that can trigger autoscale events for a ec2 autoscalegroup.
|
|
|
|
|
|
```js
|
|
window|ec2Autoscale()
|
|
```
|
|
|
|
Returns: [Ec2AutoscaleNode](/kapacitor/v1.6/nodes/ec2_autoscale_node/)
|
|
|
|
### Elapsed
|
|
|
|
Compute the elapsed time between points.
|
|
|
|
|
|
```js
|
|
window|elapsed(field string, unit time.Duration)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Eval
|
|
|
|
Create an eval node that will evaluate the given transformation function to each data point.
|
|
A list of expressions may be provided and will be evaluated in the order they are given.
|
|
The results are available to later expressions.
|
|
|
|
|
|
```js
|
|
window|eval(expressions ...ast.LambdaNode)
|
|
```
|
|
|
|
Returns: [EvalNode](/kapacitor/v1.6/nodes/eval_node/)
|
|
|
|
### First
|
|
|
|
Select the first point.
|
|
|
|
|
|
```js
|
|
window|first(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Flatten
|
|
|
|
Flatten points with similar times into a single point.
|
|
|
|
|
|
```js
|
|
window|flatten()
|
|
```
|
|
|
|
Returns: [FlattenNode](/kapacitor/v1.6/nodes/flatten_node/)
|
|
|
|
### GroupBy
|
|
|
|
Group the data by a set of tags.
|
|
|
|
Can pass literal * to group by all dimensions.
|
|
Example:
|
|
|
|
|
|
```js
|
|
|groupBy(*)
|
|
```
|
|
|
|
|
|
|
|
```js
|
|
window|groupBy(tag ...interface{})
|
|
```
|
|
|
|
Returns: [GroupByNode](/kapacitor/v1.6/nodes/group_by_node/)
|
|
|
|
### HoltWinters
|
|
|
|
Compute the Holt-Winters (/{{< latest "influxdb" "v1" >}}/query_language/functions/#holt-winters) forecast of a data set.
|
|
|
|
|
|
```js
|
|
window|holtWinters(field string, h int64, m int64, interval time.Duration)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### HoltWintersWithFit
|
|
|
|
Compute the Holt-Winters (/{{< latest "influxdb" "v1" >}}/query_language/functions/#holt-winters) forecast of a data set.
|
|
This method also outputs all the points used to fit the data in addition to the forecasted data.
|
|
|
|
|
|
```js
|
|
window|holtWintersWithFit(field string, h int64, m int64, interval time.Duration)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### HttpOut
|
|
|
|
Create an HTTP output node that caches the most recent data it has received.
|
|
The cached data is available at the given endpoint.
|
|
The endpoint is the relative path from the API endpoint of the running task.
|
|
For example, if the task endpoint is at `/kapacitor/v1/tasks/<task_id>` and endpoint is
|
|
`top10`, then the data can be requested from `/kapacitor/v1/tasks/<task_id>/top10`.
|
|
|
|
|
|
```js
|
|
window|httpOut(endpoint string)
|
|
```
|
|
|
|
Returns: [HTTPOutNode](/kapacitor/v1.6/nodes/http_out_node/)
|
|
|
|
### HttpPost
|
|
|
|
Creates an HTTP Post node that POSTS received data to the provided HTTP endpoint.
|
|
HttpPost expects 0 or 1 arguments. If 0 arguments are provided, you must specify an
|
|
endpoint property method.
|
|
|
|
|
|
```js
|
|
window|httpPost(url ...string)
|
|
```
|
|
|
|
Returns: [HTTPPostNode](/kapacitor/v1.6/nodes/http_post_node/)
|
|
|
|
### InfluxDBOut
|
|
|
|
Create an influxdb output node that will store the incoming data into InfluxDB.
|
|
|
|
|
|
```js
|
|
window|influxDBOut()
|
|
```
|
|
|
|
Returns: [InfluxDBOutNode](/kapacitor/v1.6/nodes/influx_d_b_out_node/)
|
|
|
|
### Join
|
|
|
|
Join this node with other nodes. The data is joined on timestamp.
|
|
|
|
|
|
```js
|
|
window|join(others ...Node)
|
|
```
|
|
|
|
Returns: [JoinNode](/kapacitor/v1.6/nodes/join_node/)
|
|
|
|
### K8sAutoscale
|
|
|
|
Create a node that can trigger autoscale events for a kubernetes cluster.
|
|
|
|
|
|
```js
|
|
window|k8sAutoscale()
|
|
```
|
|
|
|
Returns: [K8sAutoscaleNode](/kapacitor/v1.6/nodes/k8s_autoscale_node/)
|
|
|
|
### KapacitorLoopback
|
|
|
|
Create an kapacitor loopback node that will send data back into Kapacitor as a stream.
|
|
|
|
|
|
```js
|
|
window|kapacitorLoopback()
|
|
```
|
|
|
|
Returns: [KapacitorLoopbackNode](/kapacitor/v1.6/nodes/kapacitor_loopback_node/)
|
|
|
|
### Last
|
|
|
|
Select the last point.
|
|
|
|
|
|
```js
|
|
window|last(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Log
|
|
|
|
Create a node that logs all data it receives.
|
|
|
|
|
|
```js
|
|
window|log()
|
|
```
|
|
|
|
Returns: [LogNode](/kapacitor/v1.6/nodes/log_node/)
|
|
|
|
### Max
|
|
|
|
Select the maximum point.
|
|
|
|
|
|
```js
|
|
window|max(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Mean
|
|
|
|
Compute the mean of the data.
|
|
|
|
|
|
```js
|
|
window|mean(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Median
|
|
|
|
Compute the median of the data.
|
|
|
|
> **Note:** This method is not a selector.
|
|
If you want the median point, use `.percentile(field, 50.0)`.
|
|
|
|
|
|
```js
|
|
window|median(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Min
|
|
|
|
Select the minimum point.
|
|
|
|
|
|
```js
|
|
window|min(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Mode
|
|
|
|
Compute the mode of the data.
|
|
|
|
|
|
```js
|
|
window|mode(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### MovingAverage
|
|
|
|
Compute a moving average of the last window points.
|
|
No points are emitted until the window is full.
|
|
|
|
|
|
```js
|
|
window|movingAverage(field string, window int64)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Percentile
|
|
|
|
Select a point at the given percentile. This is a selector function, no interpolation between points is performed.
|
|
|
|
|
|
```js
|
|
window|percentile(field string, percentile float64)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Sample
|
|
|
|
Create a new node that samples the incoming points or batches.
|
|
|
|
One point will be emitted every count or duration specified.
|
|
|
|
|
|
```js
|
|
window|sample(rate interface{})
|
|
```
|
|
|
|
Returns: [SampleNode](/kapacitor/v1.6/nodes/sample_node/)
|
|
|
|
### Shift
|
|
|
|
Create a new node that shifts the incoming points or batches in time.
|
|
|
|
|
|
```js
|
|
window|shift(shift time.Duration)
|
|
```
|
|
|
|
Returns: [ShiftNode](/kapacitor/v1.6/nodes/shift_node/)
|
|
|
|
### Sideload
|
|
|
|
Create a node that can load data from external sources.
|
|
|
|
|
|
```js
|
|
window|sideload()
|
|
```
|
|
|
|
Returns: [SideloadNode](/kapacitor/v1.6/nodes/sideload_node/)
|
|
|
|
### Spread
|
|
|
|
Compute the difference between `min` and `max` points.
|
|
|
|
|
|
```js
|
|
window|spread(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### StateCount
|
|
|
|
Create a node that tracks number of consecutive points in a given state.
|
|
|
|
|
|
```js
|
|
window|stateCount(expression ast.LambdaNode)
|
|
```
|
|
|
|
Returns: [StateCountNode](/kapacitor/v1.6/nodes/state_count_node/)
|
|
|
|
### StateDuration
|
|
|
|
Create a node that tracks duration in a given state.
|
|
|
|
|
|
```js
|
|
window|stateDuration(expression ast.LambdaNode)
|
|
```
|
|
|
|
Returns: [StateDurationNode](/kapacitor/v1.6/nodes/state_duration_node/)
|
|
|
|
### Stats
|
|
|
|
Create a new stream of data that contains the internal statistics of the node.
|
|
The interval represents how often to emit the statistics based on real time.
|
|
This means the interval time is independent of the times of the data points the source node is receiving.
|
|
|
|
|
|
```js
|
|
window|stats(interval time.Duration)
|
|
```
|
|
|
|
Returns: [StatsNode](/kapacitor/v1.6/nodes/stats_node/)
|
|
|
|
### Stddev
|
|
|
|
Compute the standard deviation.
|
|
|
|
|
|
```js
|
|
window|stddev(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Sum
|
|
|
|
Compute the sum of all values.
|
|
|
|
|
|
```js
|
|
window|sum(field string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### SwarmAutoscale
|
|
|
|
Create a node that can trigger autoscale events for a Docker swarm cluster.
|
|
|
|
|
|
```js
|
|
window|swarmAutoscale()
|
|
```
|
|
|
|
Returns: [SwarmAutoscaleNode](/kapacitor/v1.6/nodes/swarm_autoscale_node/)
|
|
|
|
### Top
|
|
|
|
Select the top `num` points for `field` and sort by any extra tags or fields.
|
|
|
|
|
|
```js
|
|
window|top(num int64, field string, fieldsAndTags ...string)
|
|
```
|
|
|
|
Returns: [InfluxQLNode](/kapacitor/v1.6/nodes/influx_q_l_node/)
|
|
|
|
### Trickle
|
|
|
|
Create a new node that converts batch data to stream data.
|
|
|
|
```js
|
|
window|trickle()
|
|
```
|
|
|
|
Returns: [TrickleNode](/kapacitor/v1.6/nodes/trickle_node/)
|
|
|
|
### Union
|
|
|
|
Perform the union of this node and all other given nodes.
|
|
|
|
|
|
```js
|
|
window|union(node ...Node)
|
|
```
|
|
|
|
Returns: [UnionNode](/kapacitor/v1.6/nodes/union_node/)
|
|
|
|
### Where
|
|
|
|
Create a new node that filters the data stream by a given expression.
|
|
|
|
|
|
```js
|
|
window|where(expression ast.LambdaNode)
|
|
```
|
|
|
|
Returns: [WhereNode](/kapacitor/v1.6/nodes/where_node/)
|
|
|
|
### Window
|
|
|
|
Create a new node that windows the stream by time.
|
|
|
|
NOTE: Window can only be applied to stream edges.
|
|
|
|
|
|
```js
|
|
window|window()
|
|
```
|
|
|
|
Returns: [WindowNode](/kapacitor/v1.6/nodes/window_node/)
|