• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

temporalio / sdk-java / #425

10 Nov 2026 12:13AM UTC coverage: 71.697% (+0.06%) from 71.634%
#425

push

github

web-flow
Report poller target on each poll and in the worker heartbeat (for both fixed and autoscaling pools) (#3159)

8543 of 13993 branches covered (61.05%)

Branch coverage included in aggregate %.

58 of 65 new or added lines in 14 files covered. (89.23%)

7 existing lines in 4 files now uncovered.

33990 of 45330 relevant lines covered (74.98%)

0.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.09
/temporal-sdk/src/main/java/io/temporal/internal/worker/AsyncWorkflowPollTask.java
1
package io.temporal.internal.worker;
2

3
import static io.temporal.serviceclient.MetricsTag.METRICS_TAGS_CALL_OPTIONS_KEY;
4

5
import com.uber.m3.tally.Scope;
6
import com.uber.m3.util.ImmutableMap;
7
import io.grpc.Context;
8
import io.temporal.api.common.v1.WorkerVersionCapabilities;
9
import io.temporal.api.enums.v1.TaskQueueKind;
10
import io.temporal.api.taskqueue.v1.PollerPoolInfo;
11
import io.temporal.api.taskqueue.v1.TaskQueue;
12
import io.temporal.api.workflowservice.v1.*;
13
import io.temporal.internal.common.GrpcUtils;
14
import io.temporal.internal.common.ProtobufTimeUtils;
15
import io.temporal.serviceclient.MetricsTag;
16
import io.temporal.serviceclient.WorkflowServiceStubs;
17
import io.temporal.worker.MetricsType;
18
import io.temporal.worker.PollerTypeMetricsTag;
19
import io.temporal.worker.tuning.SlotPermit;
20
import io.temporal.worker.tuning.WorkflowSlotInfo;
21
import java.util.Objects;
22
import java.util.concurrent.CompletableFuture;
23
import java.util.concurrent.atomic.AtomicBoolean;
24
import java.util.function.IntSupplier;
25
import java.util.function.Supplier;
26
import javax.annotation.Nonnull;
27
import javax.annotation.Nullable;
28
import org.slf4j.Logger;
29
import org.slf4j.LoggerFactory;
30

31
public class AsyncWorkflowPollTask
32
    implements AsyncPoller.PollTaskAsync<WorkflowTask>, DisableNormalPolling {
33
  private static final Logger log = LoggerFactory.getLogger(AsyncWorkflowPollTask.class);
1 ✔
34
  private final TrackingSlotSupplier<WorkflowSlotInfo> slotSupplier;
35
  private final WorkflowServiceStubs service;
36
  private final Scope metricsScope;
37
  private final Scope pollerMetricScope;
38
  private final PollWorkflowTaskQueueRequest pollRequest;
39
  private final MetricsTag.TagValue taskQueueTagValue;
40
  private final boolean stickyPoller;
41
  private final Context.CancellableContext grpcContext = Context.ROOT.withCancellation();
1 ✔
42
  private final AtomicBoolean shutdown = new AtomicBoolean(false);
1 ✔
43
  private final PollerTracker pollerTracker;
44

45
  @Override
46
  public String toString() {
47
    return "AsyncWorkflowPollTask{" + "stickyPoller=" + stickyPoller + '}';
×
48
  }
49

50
  @SuppressWarnings("deprecation")
51
  public AsyncWorkflowPollTask(
52
      @Nonnull WorkflowServiceStubs service,
53
      @Nonnull String namespace,
54
      @Nonnull String taskQueue,
55
      @Nullable String stickyTaskQueue,
56
      @Nonnull String identity,
57
      @Nonnull String workerInstanceKey,
58
      @Nonnull WorkerVersioningOptions versioningOptions,
59
      @Nonnull TrackingSlotSupplier<WorkflowSlotInfo> slotSupplier,
60
      @Nonnull Scope metricsScope,
61
      @Nonnull Supplier<GetSystemInfoResponse.Capabilities> serverCapabilities,
62
      @Nonnull PollerTracker pollerTracker,
63
      String workerControlTaskQueue) {
1 ✔
64
    this.service = service;
1 ✔
65
    this.slotSupplier = slotSupplier;
1 ✔
66
    this.metricsScope = metricsScope;
1 ✔
67
    this.pollerTracker = Objects.requireNonNull(pollerTracker);
1 ✔
68

69
    PollWorkflowTaskQueueRequest.Builder pollRequestBuilder =
70
        PollWorkflowTaskQueueRequest.newBuilder()
1 ✔
71
            .setNamespace(Objects.requireNonNull(namespace))
1 ✔
72
            .setIdentity(Objects.requireNonNull(identity));
1 ✔
73

74
    pollRequestBuilder.setWorkerInstanceKey(workerInstanceKey);
1 ✔
75
    if (workerControlTaskQueue != null) {
1 !
76
      pollRequestBuilder.setWorkerControlTaskQueue(workerControlTaskQueue);
×
77
    }
78

79
    if (versioningOptions.getWorkerDeploymentOptions() != null) {
1 !
80
      pollRequestBuilder.setDeploymentOptions(
×
81
          WorkerVersioningProtoUtils.deploymentOptionsToProto(
×
82
              versioningOptions.getWorkerDeploymentOptions()));
×
83
    } else if (serverCapabilities.get().getBuildIdBasedVersioning()) {
1 ✔
84
      pollRequestBuilder.setWorkerVersionCapabilities(
1 ✔
85
          WorkerVersionCapabilities.newBuilder()
1 ✔
86
              .setBuildId(versioningOptions.getBuildId())
1 ✔
87
              .setUseVersioning(versioningOptions.isUsingVersioning())
1 ✔
88
              .build());
1 ✔
89
    } else {
90
      pollRequestBuilder.setBinaryChecksum(versioningOptions.getBuildId());
1 ✔
91
    }
92
    stickyPoller = stickyTaskQueue != null && !stickyTaskQueue.isEmpty();
1 !
93
    if (!stickyPoller) {
1 ✔
94
      taskQueueTagValue = PollerTypeMetricsTag.PollerType.WORKFLOW_TASK;
1 ✔
95
      this.pollRequest =
1 ✔
96
          pollRequestBuilder
97
              .setTaskQueue(
1 ✔
98
                  TaskQueue.newBuilder()
1 ✔
99
                      .setName(taskQueue)
1 ✔
100
                      .setKind(TaskQueueKind.TASK_QUEUE_KIND_NORMAL)
1 ✔
101
                      .build())
1 ✔
102
              .build();
1 ✔
103
      this.pollerMetricScope =
1 ✔
104
          metricsScope.tagged(
1 ✔
105
              new ImmutableMap.Builder<String, String>(1)
106
                  .put(MetricsTag.TASK_QUEUE, String.format("%s:%s", taskQueue, "sticky"))
1 ✔
107
                  .build());
1 ✔
108
    } else {
109
      taskQueueTagValue = PollerTypeMetricsTag.PollerType.WORKFLOW_STICKY_TASK;
1 ✔
110
      this.pollRequest =
1 ✔
111
          pollRequestBuilder
112
              .setTaskQueue(
1 ✔
113
                  TaskQueue.newBuilder()
1 ✔
114
                      .setName(stickyTaskQueue)
1 ✔
115
                      .setKind(TaskQueueKind.TASK_QUEUE_KIND_STICKY)
1 ✔
116
                      .setNormalName(taskQueue)
1 ✔
117
                      .build())
1 ✔
118
              .build();
1 ✔
119
      this.pollerMetricScope = metricsScope;
1 ✔
120
    }
121
  }
1 ✔
122

123
  /**
124
   * Supplies the poller pool's current scaling target. Installed by AsyncPoller, which owns the
125
   * scale report handle; null until then, and for a pool that is not autoscaling.
126
   */
127
  private volatile IntSupplier pollerTargetSupplier;
128

129
  @Override
130
  public void setPollerTargetSupplier(IntSupplier pollerTargetSupplier) {
131
    this.pollerTargetSupplier = pollerTargetSupplier;
1 ✔
132
    // Also hand it to the tracker, which is what the heartbeat builder can reach.
133
    pollerTracker.setPollerTargetSupplier(pollerTargetSupplier);
1 ✔
134
  }
1 ✔
135

136
  /** The poll request with the pool's target poller count attached. */
137
  private PollWorkflowTaskQueueRequest pollRequestWithScalingInfo() {
138
    IntSupplier supplier = pollerTargetSupplier;
1 ✔
139
    if (supplier == null) {
1 ✔
140
      return pollRequest;
1 ✔
141
    }
142
    return pollRequest.toBuilder()
1 ✔
143
        .setPollerPoolInfo(
1 ✔
144
            PollerPoolInfo.newBuilder().setTargetPollers(supplier.getAsInt()).build())
1 ✔
145
        .build();
1 ✔
146
  }
147

148
  @Override
149
  public CompletableFuture<WorkflowTask> poll(SlotPermit permit)
150
      throws AsyncPoller.PollTaskAsyncAbort {
151
    if (shutdown.get()) {
1 ✔
152
      throw new AsyncPoller.PollTaskAsyncAbort("Normal poller is disabled");
1 ✔
153
    }
154
    PollWorkflowTaskQueueRequest request = pollRequestWithScalingInfo();
1 ✔
155
    if (log.isTraceEnabled()) {
1 !
NEW
156
      log.trace("poll request begin: " + request);
×
157
    }
158

159
    MetricsTag.tagged(metricsScope, taskQueueTagValue)
1 ✔
160
        .gauge(MetricsType.NUM_POLLERS)
1 ✔
161
        .update(pollerTracker.pollStarted());
1 ✔
162

163
    CompletableFuture<PollWorkflowTaskQueueResponse> response = null;
1 ✔
164
    try {
165
      response =
1 ✔
166
          grpcContext.call(
1 ✔
167
              () ->
168
                  GrpcUtils.toCompletableFuture(
1 ✔
169
                      service
170
                          .futureStub()
1 ✔
171
                          .withOption(METRICS_TAGS_CALL_OPTIONS_KEY, metricsScope)
1 ✔
172
                          .pollWorkflowTaskQueue(request)));
1 ✔
173
    } catch (Exception e) {
×
174
      MetricsTag.tagged(metricsScope, taskQueueTagValue)
×
175
          .gauge(MetricsType.NUM_POLLERS)
×
176
          .update(pollerTracker.pollCompleted());
×
177
      throw new RuntimeException(e);
×
178
    }
1 ✔
179

180
    return response
1 ✔
181
        .thenApply(
1 ✔
182
            r -> {
183
              if (r == null || r.getTaskToken().isEmpty()) {
1 !
184
                pollerMetricScope
×
185
                    .counter(MetricsType.WORKFLOW_TASK_QUEUE_POLL_EMPTY_COUNTER)
×
186
                    .inc(1);
×
187
                return null;
×
188
              }
189
              pollerTracker.pollSucceeded();
1 ✔
190
              slotSupplier.markSlotUsed(new WorkflowSlotInfo(r, pollRequest), permit);
1 ✔
191
              pollerMetricScope
1 ✔
192
                  .counter(MetricsType.WORKFLOW_TASK_QUEUE_POLL_SUCCEED_COUNTER)
1 ✔
193
                  .inc(1);
1 ✔
194
              pollerMetricScope
1 ✔
195
                  .timer(MetricsType.WORKFLOW_TASK_SCHEDULE_TO_START_LATENCY)
1 ✔
196
                  .record(ProtobufTimeUtils.toM3Duration(r.getStartedTime(), r.getScheduledTime()));
1 ✔
197
              return new WorkflowTask(r, (reason) -> slotSupplier.releaseSlot(reason, permit));
1 ✔
198
            })
199
        .whenComplete(
1 ✔
200
            (r, e) -> {
201
              MetricsTag.tagged(metricsScope, taskQueueTagValue)
1 ✔
202
                  .gauge(MetricsType.NUM_POLLERS)
1 ✔
203
                  .update(pollerTracker.pollCompleted());
1 ✔
204
            });
1 ✔
205
  }
206

207
  @Override
208
  public void cancel(Throwable cause) {
209
    grpcContext.cancel(cause);
1 ✔
210
  }
1 ✔
211

212
  @Override
213
  public void disableNormalPoll() {
214
    if (stickyPoller) {
1 !
215
      throw new IllegalStateException("Cannot disable normal poll for sticky poller");
×
216
    }
217
    shutdown.set(true);
1 ✔
218
  }
1 ✔
219

220
  @Override
221
  public String getLabel() {
222
    return stickyPoller ? "StickyWorkflowPollTask" : "NormalWorkflowPollTask";
1 ✔
223
  }
224
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc