*/
    @Override
    public ModelTransformerContext initialize(ModelBuilderRequest request, ModelProblemCollector collector) {
        // We must assume the TransformerContext was created using this.newTransformerContextBuilder()
        DefaultModelProblemCollector problems = (DefaultModelProblemCollector) collector;
        return new ModelTransformerContext() {

            @Override
            public Path locate(Path path) {

meshConfig:
  enableTracing: true
  extensionProviders:
  - name: test-otel
    opentelemetry:
      service: opentelemetry-collector.istio-system.svc.cluster.local
      port: 4317
  - name: test-otel-http
    opentelemetry:
      service: opentelemetry-collector.istio-system.svc.cluster.local
      port: 4318
      http:
        path: "v1/traces"
        timeout: 10s
        headers:

    def "does not schedule garbage collection check when GC strategy is unknown" () {
        when:
        new DefaultGarbageCollectionMonitor(GarbageCollectorMonitoringStrategy.UNKNOWN, scheduledExecutorService)

        then:
        0 * scheduledExecutorService.scheduleAtFixedRate(_, _, _, _)
    }

    def "heap stats defaults to empty given unknown garbage collector"() {
        given:

  protobuf::TextFormat::Parser parser;
  // Don't produce errors when attempting to parse text format as it would fail
  // when the input is actually a binary file.
  NoOpErrorCollector collector;
  parser.RecordErrorsTo(&collector);
  // Attempt to parse as text.
  absl::string_view text_proto_without_prefix = text_proto;
  if (!prefix_to_strip.empty()) {
    TF_RETURN_IF_ERROR(

type PodGCControllerConfiguration struct {
	// terminatedPodGCThreshold is the number of terminated pods that can exist
	// before the terminated pod garbage collector starts deleting terminated pods.
	// If <= 0, the terminated pod garbage collector is disabled.
	TerminatedPodGCThreshold int32

            String publishedVariantName = outgoingConfigurationName + StringUtils.capitalize(subvariant.getName());
            visitVariant(collector, seen, subvariant, publishedVariantName);
        }
    }

    private void visitVariant(
        Consumer<UsageContext> collector,
        Set<String> seen,
        ConfigurationVariant subvariant,
        String name
    ) {

  selector:
    app: jaeger
---
apiVersion: v1
kind: Service
metadata:
  name: jaeger-collector
  namespace: istio-system
  labels:
    app: jaeger
spec:
  type: ClusterIP
  ports:
  - name: jaeger-collector-http
    port: 14268
    targetPort: 14268
    protocol: TCP
  - name: jaeger-collector-grpc
    port: 14250
    targetPort: 14250
    protocol: TCP
  - port: 9411

        Object value = it[key]
        toExclude(key, value)
    }

    private void collectOperands(Object value, List<String> collector) {
        if (value instanceof List) {
            value.each {
                collectOperands(it, collector)
            }
        } else {
            collector << toExclude(value)
        }
    }

    private String toExclude(String opType, Object value) {

	ch <- volumeStatsInodesUsedDesc
	ch <- volumeStatsHealthAbnormalDesc
}

// CollectWithStability implements the metrics.StableCollector interface.
func (collector *volumeStatsCollector) CollectWithStability(ch chan<- metrics.Metric) {
	ctx := context.Background()
	podStats, err := collector.statsProvider.ListPodStats(ctx)
	if err != nil {
		return
	}
	addGauge := func(desc *metrics.Desc, pvcRef *stats.PVCReference, v float64, lv ...string) {

        unit.addSource("action", src)
        ClassCollector collector = new ClassCollector(target: target)
        unit.setClassgenCallback(collector);
        unit.compile(Phases.CLASS_GENERATION);

        Object instance = JavaReflectionUtil.newInstance(collector.generated)
        instance.key = counter.getAndIncrement()
        ACTIONS[instance.key] = action
        return instance