metadata:
  name: fortio-deploy
spec:
  replicas: 1
  selector:
    matchLabels:
      app: fortio
  template:
    metadata:
      annotations:
        # This annotation causes Envoy to serve cluster.outbound statistics via 15000/stats
        # in addition to the stats normally served by Istio. The Circuit Breaking example task
        # gives an example of inspecting Envoy stats via proxy config.
        proxy.istio.io/config: |-

//go:generate stringer -type=TargetType -trimprefix=Target $GOFILE

// Constants for target types
const (
	_ TargetType = iota
	TargetConsole
	TargetHTTP
	TargetKafka
)

// TargetStats contains statistics for a target.
type TargetStats struct {
	// QueueLength is the queue length if any messages are queued.
	QueueLength int

	// TotalMessages is the total number of messages sent in the lifetime of the target

	"strings"
	"sync"
	"sync/atomic"

	xhttp "github.com/minio/minio/internal/http"
	"github.com/prometheus/client_golang/prometheus"
)

const (
	apiGetObject = "GetObject"
)

// connStats - Network statistics
// Count total input/output transferred bytes during
// the server's life.
type connStats struct {
	internodeInputBytes  uint64
	internodeOutputBytes uint64
	s3InputBytes         uint64
	s3OutputBytes        uint64

    const Tensor& input_tensor = context->input(0);

    // Use the same input for the first output.
    context->set_output(0, input_tensor);

    // Calculate min/max statistics.
    const auto input_flat = input_tensor.flat<float>();
    Tensor *min_output = nullptr, *max_output = nullptr;
    OP_REQUIRES_OK(context, context->allocate_output("min", {}, &min_output));

// static-range quantization.
//
// The resulting `ModuleOp` contains quantized StableHLO ops serialized in
// `TF::XlaCallModuleOp`s. They are quantized using the statistics collected
// after the calibration step, corresponding to each `TF::CustomAggregatorOp`s
// in the input module op.
//
// TODO: b/320607042 - Add tests for this component on the python layer.

    private final TaskStatistics statistics;
    private final boolean eagerlyCreateLazyTasks;

    private MutableModelNode modelNode;

    public DefaultTaskContainer(
        ProjectInternal project,
        Instantiator instantiator,
        TaskIdentityFactory taskIdentityFactory,
        ITaskFactory taskFactory,
        TaskStatistics statistics,
        BuildOperationRunner buildOperationRunner,

                thread.blockUntil.worker2Executed
            }
        }

        then:
        instant.worker1Executed > instant.worker2Executed
    }

    def "gathers statistics when acquiring a project lock and statistics flag is set"() {
        def projectLock = workerLeaseService.getProjectLock(path("root"), path(":project"))

        when:

                }
            }

            task noActions(dependsOn: executedTask) {}
        """
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "task outcome statistics are reported"() {
        when:
        run "adHocTask", "executedTask"

        then:
        result.assertTasksNotSkipped(":adHocTask", ":executedTask")

  let summary = "Inserts `CalibrationStatisticsSaver` op to collect and save calibration statistics.";
  let description = [{
    Finds all `CustomAggregator` ops in the each function and add a single
    `CalibrationStatisticsSaver` op at the end of the function to collect their
    statistics.
  }];
  let options = [

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.tasks.execution.statistics;

import static com.google.common.base.Preconditions.checkArgument;

public class TaskExecutionStatistics {
    private final int executedTasksCount;
    private final int fromCacheTaskCount;