}
    }
    {{ end }}
    {{ if and .envoy_metrics_service_address .statsd }}
    ,
    {{ end }}
    {{ if .statsd }}
    {
      "name": "envoy.stat_sinks.statsd",
      "typed_config": {
        "@type": "type.googleapis.com/envoy.config.metrics.v3.StatsdSink",
        "address": {
          "socket_address": {{ .statsd }}
        }
      }
    }
    {{ end }}
  ]
  {{ end }}

          "envoy_grpc": {
            "cluster_name": "envoy_metrics_service"
          }
        }
      }
    }
    
    
    ,
    
    
    {
      "name": "envoy.stat_sinks.statsd",
      "typed_config": {
        "@type": "type.googleapis.com/envoy.config.metrics.v3.StatsdSink",
        "address": {
          "socket_address": {"address": "10.1.1.1", "port_value": 9125}
        }
      }

	gsm := got.GetStatsConfig().GetStatsMatcher()

	if stats.prefixes == "" {
		stats.prefixes = v2Prefixes + requiredEnvoyStatsMatcherInclusionPrefixes + v2Suffix
	} else {
		stats.prefixes = v2Prefixes + stats.prefixes + "," + requiredEnvoyStatsMatcherInclusionPrefixes + v2Suffix
	}
	if stats.suffixes == "" {
		stats.suffixes = rbacEnvoyStatsMatcherInclusionSuffix

		return 0
	}

	stats.RLock()
	defer stats.RUnlock()

	val, ok := stats.apiStats[api]
	if ok {
		return val
	}

	return 0
}

// Load returns the recorded stats.
func (stats *HTTPAPIStats) Load(toLower bool) map[string]int {
	if stats == nil {
		return map[string]int{}
	}

	stats.RLock()
	defer stats.RUnlock()

	if gcTotal != stats.GCTotalTime {
		t.Errorf("manually computed total does not match GCTotalTime: %d cpu-ns vs. %d cpu-ns", gcTotal, stats.GCTotalTime)
	}
	scavTotal := stats.ScavengeAssistTime + stats.ScavengeBgTime
	if scavTotal != stats.ScavengeTotalTime {
		t.Errorf("manually computed total does not match ScavengeTotalTime: %d cpu-ns vs. %d cpu-ns", scavTotal, stats.ScavengeTotalTime)
	}

		}
		if hm.Mem != nil && len(hm.Mem.Info.Addr) > 0 {
			labels := map[string]string{}
			stats := hm.Mem.Info
			updateResourceMetrics(memSubsystem, total, float64(stats.Total), labels, false)
			updateResourceMetrics(memSubsystem, memUsed, float64(stats.Used), labels, false)
			perc := math.Round(float64(stats.Used*100*100)/float64(stats.Total)) / 100

	// any conversion.
	readGCStats(&stats.Pause)
	n := len(stats.Pause) - 3
	stats.LastGC = time.Unix(0, int64(stats.Pause[n]))
	stats.NumGC = int64(stats.Pause[n+1])
	stats.PauseTotal = stats.Pause[n+2]
	n /= 2 // buffer holds pauses and end times
	stats.Pause = stats.Pause[:n]

	if cap(stats.PauseEnd) < maxPause {
		stats.PauseEnd = make([]time.Time, 0, maxPause)
	}
	stats.PauseEnd = stats.PauseEnd[:0]

  ASSERT_THAT(statistics_map.statistics(), ElementsAre(Key("1")));

  const CalibrationStatistics& stats = statistics_map.statistics().at("1");
  ASSERT_TRUE(stats.has_average_min_max_statistics());
  EXPECT_FLOAT_EQ(stats.average_min_max_statistics().min_sum(), 1.f);
  EXPECT_FLOAT_EQ(stats.average_min_max_statistics().max_sum(), 5.f);
  EXPECT_EQ(stats.average_min_max_statistics().num_samples(), 1);
}

    }
    absl::Status status = ValidateSPAllocatorStats(c_stats);
    if (!status.ok()) {
      LOG(ERROR) << status.message();
      return absl::nullopt;
    }
    ::stream_executor::AllocatorStats stats;
    stats.num_allocs = c_stats.num_allocs;
    stats.bytes_in_use = c_stats.bytes_in_use;
    stats.peak_bytes_in_use = c_stats.peak_bytes_in_use;
    stats.largest_alloc_size = c_stats.largest_alloc_size;

			networking.ListenerProtocolHTTP,
			nil,
			map[string]string{
				"istio.stats": cfg,
			},
		},
		{
			"default prometheus",
			[]config.Config{newTelemetry("istio-system", emptyPrometheus)},
			sidecar,
			networking.ListenerClassSidecarOutbound,
			networking.ListenerProtocolHTTP,
			nil,
			map[string]string{
				"istio.stats": "{}",
			},
		},
		{
			"default provider prometheus",