informers map[reflect.Type]cache.SharedIndexInformer
	// startedInformers is used for tracking which informers have been started.
	// This allows Start() to be called multiple times safely.
	startedInformers map[reflect.Type]bool
	// wg tracks how many goroutines were started.
	wg sync.WaitGroup
	// shuttingDown is true when Shutdown has been called. It may still be running
	// because it needs to wait for goroutines.

Next steps:
{{- if (eq .Values.profile "ambient") }}
  * Get started with ambient: https://istio.io/latest/docs/ops/ambient/getting-started/
  * Review ambient's architecture: https://istio.io/latest/docs/ops/ambient/architecture/
{{- else }}
  * Deploy a Gateway: https://istio.io/latest/docs/setup/additional-setup/gateway/
  * Try out our tasks to get started on common configurations:
    * https://istio.io/latest/docs/tasks/traffic-management

	}
	if err == nil {
		if remountingLogStr == "" {
			klog.V(1).InfoS(volumeToMount.GenerateMsgDetailed("operationExecutor.MountVolume started", remountingLogStr), "pod", klog.KObj(volumeToMount.Pod))
		} else {
			klog.V(5).InfoS(volumeToMount.GenerateMsgDetailed("operationExecutor.MountVolume started", remountingLogStr), "pod", klog.KObj(volumeToMount.Pod))
		}
	}
}

        _ * startEvent.getDisplayName() >> 'task started'
        _ * startEvent.getDescriptor() >> taskDescriptor

        adapter.onEvent(startEvent)

        then:
        1 * listener.statusChanged(_ as TaskStartEvent) >> { TaskStartEvent event ->
            assertTrue event.eventTime == 999
            assertTrue event.displayName == "task started"
            assertTrue event.descriptor.name == 'some task'

	<-qm.informersStarted

	monitors := qm.monitors
	started := 0
	for _, monitor := range monitors {
		if monitor.stopCh == nil {
			monitor.stopCh = make(chan struct{})
			qm.informerFactory.Start(qm.stopCh)
			go monitor.Run()
			started++
		}
	}
	klog.FromContext(ctx).V(4).Info("QuotaMonitor finished starting monitors", "new", started, "total", len(monitors))
}

```bash
kubectl -n <namespace> apply -f ./telemetry.yaml
```

In this example, we deploy it to the default namespace, which is where the sample apps
from the [getting started](https://istio.io/latest/docs/setup/getting-started) are also deployed.

```bash
kubectl apply -f ./telemetry.yaml
```

The core config is:

```yaml
tracing:
- providers:
  - name: otel-tracing

        _ * startEvent.getDisplayName() >> 'Test Work started'
        _ * startEvent.getDescriptor() >> workItemDescriptor

        adapter.onEvent(startEvent)

        then:
        1 * listener.statusChanged(_ as WorkItemStartEvent) >> { WorkItemStartEvent event ->
            assert event.eventTime == 999
            assert event.displayName == "Test Work started"
            assert event.descriptor.displayName == 'Test Work'

	return getTestRunningStatusWithStarted(true)
}

func getTestRunningStatusWithStarted(started bool) v1.PodStatus {
	containerStatus := v1.ContainerStatus{
		Name:        testContainerName,
		ContainerID: testContainerID.String(),
	}
	containerStatus.State.Running = &v1.ContainerStateRunning{StartedAt: metav1.Now()}
	containerStatus.Started = &started
	podStatus := v1.PodStatus{
		Phase:             v1.PodRunning,

// restartProcess starts a new process passing it the active fd's. It
// doesn't fork, but starts a new process using the same environment and
// arguments as when it was originally started. This allows for a newly
// deployed binary to be started. It returns the pid of the newly started
// process when successful.
func restartProcess() error {
	if runtime.GOOS == globalWindowsOSName {
		cmd := exec.Command(os.Args[0], os.Args[1:]...)

          }
        },
        "ready": true,
        "restartCount": 5,
        "image": "imageValue",
        "imageID": "imageIDValue",
        "containerID": "containerIDValue",
        "started": true,
        "allocatedResources": {
          "allocatedResourcesKey": "0"
        },
        "resources": {
          "limits": {
            "limitsKey": "0"
          },
          "requests": {