Combiner | A Combine-based version of ReactorKit

A Collector’s BinaryOperator returned by combiner() will only be used when used for parallel streams, however the combiner() method itself will be invoked when calling Stream.collect() to retrieve that combiner, in the JDK’s implementation (see ReduceOps.makeRef(Collector)).

You thus have 2 options:

• either return null, which would cause a NullPointerException if your collector is used in a parallel Stream, at the time the combiner needs to be used;
• or return a BinaryOperator that actually throws the exception when called:

Maybe typo, you should use the type State = ReturnType; in useSelector

reducers.ts:

Handling a list of collectors with arbitrary accumulator types as a flat list can’t be done in a type safe way, as it would require declaring n type variables to capture these types, where n is the actual list size.

Therefore, you can only implement the processing as a composition of operations, each with a finite number of components know at compile time, like your recursive approach.

This still has potential for simplifications, like replacing downstreamCollectors.size() == 0 with downstreamCollectors.isEmpty() or downstreamCollectors.stream().skip(1).toList() with a copying free downstreamCollectors.subList(1, downstreamCollectors.size()).

But the biggest impact has replacing the recursive code with a Stream Reduction operation:

I agree with @c69.

I would like to summarize the points:

1. We need to enhance the duration time because it will increase the alignment period which will help to look back farther to include data that has been ingested already.

2. We should use the duration, or the duration window, to prevent a condition from being met due to a single measurement. In the Google Cloud Console, use the following fields to configure the duration:

   • Legacy interface: The For field of the alerting policy Configuration pane.
   • Preview interface: The Time above threshold (or Time below
     threshold) field in the Configure trigger step.

3. So we should set the duration window to be long enough to minimize false positives, but short enough to ensure that incidents are opened in a timely way.

You can refer to Alerting behaviour for more details.

Also for MQL alerting policies are a bit different. The MQL query, an alerting-policy condition includes two values:

The number of input time series that must satisfy the condition. The value can be any of the following:

• A single time series.

• A specific number of time series.

• A percentage of time series.

• All time series.

Duration of the alert state, that is, how long the alert condition must continuously evaluate to true.

And in MQL there must be only condition in the policy. You can't use multiple conditions in MQL-based alerting policies.

For more details please refer Alerting policies with MQL

Combine reducer adds namespaces to the state controlled by each reducer based on the keys of the object you pass in. When you don't use combine reducer, there won't be a namespace. So change state.rootReducer to state.

Looks pretty straightforward to translate it directly:

According with this documentation when you create a channel, you need to:

• Enable the Pub/Sub API and create a topic.
• Configure the notification channel for a topic.
• Authorize a service account.
• Set the notification channel in an alerting policy.

To use a Pub/Sub notification channel in an alerting policy, select Pub/Sub as the channel type, and then select the topic. By default, the alerting backend attempts to generate a JSON packet with version 1.2 formatting.

By default the metadata field needs to have the following values:

In the default case of your therm reducer you have

configureStore takes an object with a reducer key.

It should be