zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove unused MetricsLoggerAndExporter

Browse Source 
Bug: None
Change-Id: I9e05e5c29cd80bf991bd50c3bd4ee4f09ddf8134
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/281420
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Auto-Submit: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38531}
This commit is contained in:
Artem Titov
2022-11-01 22:45:51 +01:00
committed by WebRTC LUCI CQ
parent 14687666a4
commit 19813a4222
7 changed files with 1 additions and 638 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
api/test/metrics/BUILD.gn
View File

@ -18,7 +18,6 @@ group("metrics") {
":metrics_accumulator",
":metrics_exporter",
":metrics_logger",
":metrics_logger_and_exporter",
":stdout_metrics_exporter",
]
}
@ -30,7 +29,6 @@ if (rtc_include_tests) {
deps = [
":global_metrics_logger_and_exporter_test",
":metrics_accumulator_test",
":metrics_logger_and_exporter_test",
":metrics_logger_test",
":print_result_proxy_metrics_exporter_test",
":stdout_metrics_exporter_test",
@ -176,29 +174,6 @@ rtc_library("print_result_proxy_metrics_exporter") {
]
}
rtc_library("metrics_logger_and_exporter") {
visibility = [ "*" ]
sources = [
"metrics_logger_and_exporter.cc",
"metrics_logger_and_exporter.h",
]
deps = [
":metric",
":metrics_exporter",
":metrics_logger",
"../../../rtc_base:checks",
"../../../rtc_base:logging",
"../../../rtc_base/synchronization:mutex",
"../../../system_wrappers",
"../../numerics",
]
absl_deps = [
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional",
]
}
rtc_library("global_metrics_logger_and_exporter") {
visibility = [ "*" ]
sources = [
@ -208,7 +183,6 @@ rtc_library("global_metrics_logger_and_exporter") {
deps = [
":metrics_exporter",
":metrics_logger",
":metrics_logger_and_exporter",
"../../../rtc_base:checks",
"../../../system_wrappers",
]
@ -262,20 +236,6 @@ if (rtc_include_tests) {
]
}
rtc_library("metrics_logger_and_exporter_test") {
testonly = true
sources = [ "metrics_logger_and_exporter_test.cc" ]
deps = [
":metric",
":metrics_exporter",
":metrics_logger_and_exporter",
"../../../system_wrappers",
"../../../test:test_support",
"../../numerics",
]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
}
rtc_library("global_metrics_logger_and_exporter_test") {
testonly = true
sources = [ "global_metrics_logger_and_exporter_test.cc" ]
@ -284,7 +244,6 @@ if (rtc_include_tests) {
":metric",
":metrics_exporter",
":metrics_logger",
":metrics_logger_and_exporter",
"../../../system_wrappers",
"../../../test:test_support",
]

1
api/test/metrics/global_metrics_logger_and_exporter.cc
View File

@ -15,7 +15,6 @@
#include "api/test/metrics/metrics_exporter.h"
#include "api/test/metrics/metrics_logger.h"
#include "api/test/metrics/metrics_logger_and_exporter.h"
#include "rtc_base/checks.h"
#include "system_wrappers/include/clock.h"

2
api/test/metrics/global_metrics_logger_and_exporter.h
View File

@ -15,7 +15,7 @@
#include <vector>
#include "api/test/metrics/metrics_exporter.h"
#include "api/test/metrics/metrics_logger_and_exporter.h"
#include "api/test/metrics/metrics_logger.h"
namespace webrtc {
namespace test {

129
api/test/metrics/metrics_logger_and_exporter.cc
View File

@ -1,129 +0,0 @@
/*
* Copyright (c) 2022 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "api/test/metrics/metrics_logger_and_exporter.h"
#include <map>
#include <string>
#include <utility>
#include <vector>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/numerics/samples_stats_counter.h"
#include "api/test/metrics/metric.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/synchronization/mutex.h"
namespace webrtc {
namespace test {
namespace {
Metric::Stats ToStats(const SamplesStatsCounter& values) {
if (values.IsEmpty()) {
return Metric::Stats();
}
return Metric::Stats{.mean = values.GetAverage(),
.stddev = values.GetStandardDeviation(),
.min = values.GetMin(),
.max = values.GetMax()};
}
} // namespace
MetricsLoggerAndExporter::~MetricsLoggerAndExporter() {
bool export_result = Export();
if (crash_on_export_failure_) {
RTC_CHECK(export_result);
} else {
RTC_LOG(LS_ERROR) << "One of exporters failed to export collected metrics";
}
}
void MetricsLoggerAndExporter::LogSingleValueMetric(
absl::string_view name,
absl::string_view test_case_name,
double value,
Unit unit,
ImprovementDirection improvement_direction,
std::map<std::string, std::string> metadata) {
MutexLock lock(&mutex_);
metrics_.push_back(Metric{
.name = std::string(name),
.unit = unit,
.improvement_direction = improvement_direction,
.test_case = std::string(test_case_name),
.metric_metadata = std::move(metadata),
.time_series =
Metric::TimeSeries{.samples = std::vector{Metric::TimeSeries::Sample{
.timestamp = Now(), .value = value}}},
.stats = Metric::Stats{
.mean = value, .stddev = absl::nullopt, .min = value, .max = value}});
}
void MetricsLoggerAndExporter::LogMetric(
absl::string_view name,
absl::string_view test_case_name,
const SamplesStatsCounter& values,
Unit unit,
ImprovementDirection improvement_direction,
std::map<std::string, std::string> metadata) {
MutexLock lock(&mutex_);
Metric::TimeSeries time_series;
for (const SamplesStatsCounter::StatsSample& sample :
values.GetTimedSamples()) {
time_series.samples.push_back(
Metric::TimeSeries::Sample{.timestamp = sample.time,
.value = sample.value,
.sample_metadata = sample.metadata});
}
metrics_.push_back(Metric{.name = std::string(name),
.unit = unit,
.improvement_direction = improvement_direction,
.test_case = std::string(test_case_name),
.metric_metadata = std::move(metadata),
.time_series = std::move(time_series),
.stats = ToStats(values)});
}
void MetricsLoggerAndExporter::LogMetric(
absl::string_view name,
absl::string_view test_case_name,
const Metric::Stats& metric_stats,
Unit unit,
ImprovementDirection improvement_direction,
std::map<std::string, std::string> metadata) {
MutexLock lock(&mutex_);
metrics_.push_back(Metric{.name = std::string(name),
.unit = unit,
.improvement_direction = improvement_direction,
.test_case = std::string(test_case_name),
.metric_metadata = std::move(metadata),
.time_series = Metric::TimeSeries{.samples = {}},
.stats = std::move(metric_stats)});
}
Timestamp MetricsLoggerAndExporter::Now() {
return clock_->CurrentTime();
}
bool MetricsLoggerAndExporter::Export() {
MutexLock lock(&mutex_);
bool success = true;
for (auto& exporter : exporters_) {
bool export_result = exporter->Export(metrics_);
success = success && export_result;
}
return success;
}
} // namespace test
} // namespace webrtc

96
api/test/metrics/metrics_logger_and_exporter.h
View File

@ -1,96 +0,0 @@
/*
* Copyright (c) 2022 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef API_TEST_METRICS_METRICS_LOGGER_AND_EXPORTER_H_
#define API_TEST_METRICS_METRICS_LOGGER_AND_EXPORTER_H_
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "absl/strings/string_view.h"
#include "api/numerics/samples_stats_counter.h"
#include "api/test/metrics/metric.h"
#include "api/test/metrics/metrics_exporter.h"
#include "api/test/metrics/metrics_logger.h"
#include "rtc_base/synchronization/mutex.h"
#include "system_wrappers/include/clock.h"
namespace webrtc {
namespace test {
// Combines metrics logging and exporting to provide simple API to automatically
// export metrics at the end of the scope.
class MetricsLoggerAndExporter : public MetricsLogger {
public:
// `crash_on_export_failure` - makes MetricsLoggerAndExporter to crash if
// any of exporters failed to export data.
MetricsLoggerAndExporter(
webrtc::Clock* clock,
std::vector<std::unique_ptr<MetricsExporter>> exporters,
bool crash_on_export_failure = true)
: clock_(clock),
crash_on_export_failure_(crash_on_export_failure),
exporters_(std::move(exporters)) {}
~MetricsLoggerAndExporter() override;
// Adds a metric with a single value.
// `metadata` - metric's level metadata to add.
void LogSingleValueMetric(
absl::string_view name,
absl::string_view test_case_name,
double value,
Unit unit,
ImprovementDirection improvement_direction,
std::map<std::string, std::string> metadata = {}) override;
// Adds metrics with a time series created based on the provided `values`.
// `metadata` - metric's level metadata to add.
void LogMetric(absl::string_view name,
absl::string_view test_case_name,
const SamplesStatsCounter& values,
Unit unit,
ImprovementDirection improvement_direction,
std::map<std::string, std::string> metadata = {}) override;
// Adds metric with a time series with only stats object and without actual
// collected values.
// `metadata` - metric's level metadata to add.
void LogMetric(absl::string_view name,
absl::string_view test_case_name,
const Metric::Stats& metric_stats,
Unit unit,
ImprovementDirection improvement_direction,
std::map<std::string, std::string> metadata = {}) override;
// Returns all metrics collected by this logger.
std::vector<Metric> GetCollectedMetrics() const override {
MutexLock lock(&mutex_);
return metrics_;
}
private:
webrtc::Timestamp Now();
bool Export();
webrtc::Clock* const clock_;
const bool crash_on_export_failure_;
mutable Mutex mutex_;
std::vector<Metric> metrics_ RTC_GUARDED_BY(mutex_);
std::vector<std::unique_ptr<MetricsExporter>> exporters_;
};
} // namespace test
} // namespace webrtc
#endif // API_TEST_METRICS_METRICS_LOGGER_AND_EXPORTER_H_

361
api/test/metrics/metrics_logger_and_exporter_test.cc
View File

@ -1,361 +0,0 @@
/*
* Copyright (c) 2022 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "api/test/metrics/metrics_logger_and_exporter.h"
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "absl/types/optional.h"
#include "api/numerics/samples_stats_counter.h"
#include "api/test/metrics/metric.h"
#include "api/test/metrics/metrics_exporter.h"
#include "system_wrappers/include/clock.h"
#include "test/gmock.h"
#include "test/gtest.h"
namespace webrtc {
namespace test {
namespace {
using ::testing::Eq;
using ::testing::IsEmpty;
std::map<std::string, std::string> DefaultMetadata() {
return std::map<std::string, std::string>{{"key", "value"}};
}
struct TestMetricsExporterFactory {
public:
std::unique_ptr<MetricsExporter> CreateExporter() {
return std::make_unique<TestMetricsExporter>(this, /*export_result=*/true);
}
std::unique_ptr<MetricsExporter> CreateFailureExporter() {
return std::make_unique<TestMetricsExporter>(this, /*export_result=*/false);
}
std::vector<Metric> exported_metrics;
private:
class TestMetricsExporter : public MetricsExporter {
public:
TestMetricsExporter(TestMetricsExporterFactory* factory, bool export_result)
: factory_(factory), export_result_(export_result) {}
~TestMetricsExporter() override = default;
bool Export(rtc::ArrayView<const Metric> metrics) override {
factory_->exported_metrics =
std::vector<Metric>(metrics.begin(), metrics.end());
return export_result_;
}
TestMetricsExporterFactory* factory_;
bool export_result_;
};
};
TEST(MetricsLoggerAndExporterTest, LogSingleValueMetricRecordsMetric) {
TestMetricsExporterFactory exporter_factory;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters));
logger.LogSingleValueMetric(
"metric_name", "test_case_name",
/*value=*/10, Unit::kMilliseconds,
ImprovementDirection::kBiggerIsBetter,
std::map<std::string, std::string>{{"key", "value"}});
}
std::vector<Metric> metrics = exporter_factory.exported_metrics;
ASSERT_THAT(metrics.size(), Eq(1lu));
const Metric& metric = metrics[0];
EXPECT_THAT(metric.name, Eq("metric_name"));
EXPECT_THAT(metric.test_case, Eq("test_case_name"));
EXPECT_THAT(metric.unit, Eq(Unit::kMilliseconds));
EXPECT_THAT(metric.improvement_direction,
Eq(ImprovementDirection::kBiggerIsBetter));
EXPECT_THAT(metric.metric_metadata,
Eq(std::map<std::string, std::string>{{"key", "value"}}));
ASSERT_THAT(metric.time_series.samples.size(), Eq(1lu));
EXPECT_THAT(metric.time_series.samples[0].value, Eq(10.0));
EXPECT_THAT(metric.time_series.samples[0].sample_metadata,
Eq(std::map<std::string, std::string>{}));
ASSERT_THAT(metric.stats.mean, absl::optional<double>(10.0));
ASSERT_THAT(metric.stats.stddev, absl::nullopt);
ASSERT_THAT(metric.stats.min, absl::optional<double>(10.0));
ASSERT_THAT(metric.stats.max, absl::optional<double>(10.0));
}
TEST(MetricsLoggerAndExporterTest,
LogMetricWithSamplesStatsCounterRecordsMetric) {
TestMetricsExporterFactory exporter_factory;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters));
SamplesStatsCounter values;
values.AddSample(SamplesStatsCounter::StatsSample{
.value = 10,
.time = Clock::GetRealTimeClock()->CurrentTime(),
.metadata =
std::map<std::string, std::string>{{"point_key1", "value1"}}});
values.AddSample(SamplesStatsCounter::StatsSample{
.value = 20,
.time = Clock::GetRealTimeClock()->CurrentTime(),
.metadata =
std::map<std::string, std::string>{{"point_key2", "value2"}}});
logger.LogMetric("metric_name", "test_case_name", values,
Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
std::map<std::string, std::string>{{"key", "value"}});
}
std::vector<Metric> metrics = exporter_factory.exported_metrics;
ASSERT_THAT(metrics.size(), Eq(1lu));
const Metric& metric = metrics[0];
EXPECT_THAT(metric.name, Eq("metric_name"));
EXPECT_THAT(metric.test_case, Eq("test_case_name"));
EXPECT_THAT(metric.unit, Eq(Unit::kMilliseconds));
EXPECT_THAT(metric.improvement_direction,
Eq(ImprovementDirection::kBiggerIsBetter));
EXPECT_THAT(metric.metric_metadata,
Eq(std::map<std::string, std::string>{{"key", "value"}}));
ASSERT_THAT(metric.time_series.samples.size(), Eq(2lu));
EXPECT_THAT(metric.time_series.samples[0].value, Eq(10.0));
EXPECT_THAT(metric.time_series.samples[0].sample_metadata,
Eq(std::map<std::string, std::string>{{"point_key1", "value1"}}));
EXPECT_THAT(metric.time_series.samples[1].value, Eq(20.0));
EXPECT_THAT(metric.time_series.samples[1].sample_metadata,
Eq(std::map<std::string, std::string>{{"point_key2", "value2"}}));
ASSERT_THAT(metric.stats.mean, absl::optional<double>(15.0));
ASSERT_THAT(metric.stats.stddev, absl::optional<double>(5.0));
ASSERT_THAT(metric.stats.min, absl::optional<double>(10.0));
ASSERT_THAT(metric.stats.max, absl::optional<double>(20.0));
}
TEST(MetricsLoggerAndExporterTest,
LogMetricWithEmptySamplesStatsCounterRecordsEmptyMetric) {
TestMetricsExporterFactory exporter_factory;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters));
SamplesStatsCounter values;
logger.LogMetric("metric_name", "test_case_name", values, Unit::kUnitless,
ImprovementDirection::kBiggerIsBetter, DefaultMetadata());
}
std::vector<Metric> metrics = exporter_factory.exported_metrics;
ASSERT_THAT(metrics.size(), Eq(1lu));
EXPECT_THAT(metrics[0].name, Eq("metric_name"));
EXPECT_THAT(metrics[0].test_case, Eq("test_case_name"));
EXPECT_THAT(metrics[0].time_series.samples, IsEmpty());
ASSERT_THAT(metrics[0].stats.mean, Eq(absl::nullopt));
ASSERT_THAT(metrics[0].stats.stddev, Eq(absl::nullopt));
ASSERT_THAT(metrics[0].stats.min, Eq(absl::nullopt));
ASSERT_THAT(metrics[0].stats.max, Eq(absl::nullopt));
}
TEST(MetricsLoggerAndExporterTest, LogMetricWithStatsRecordsMetric) {
TestMetricsExporterFactory exporter_factory;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters));
Metric::Stats metric_stats{.mean = 15, .stddev = 5, .min = 10, .max = 20};
logger.LogMetric("metric_name", "test_case_name", metric_stats,
Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
std::map<std::string, std::string>{{"key", "value"}});
}
std::vector<Metric> metrics = exporter_factory.exported_metrics;
ASSERT_THAT(metrics.size(), Eq(1lu));
const Metric& metric = metrics[0];
EXPECT_THAT(metric.name, Eq("metric_name"));
EXPECT_THAT(metric.test_case, Eq("test_case_name"));
EXPECT_THAT(metric.unit, Eq(Unit::kMilliseconds));
EXPECT_THAT(metric.improvement_direction,
Eq(ImprovementDirection::kBiggerIsBetter));
EXPECT_THAT(metric.metric_metadata,
Eq(std::map<std::string, std::string>{{"key", "value"}}));
ASSERT_THAT(metric.time_series.samples.size(), Eq(0lu));
ASSERT_THAT(metric.stats.mean, absl::optional<double>(15.0));
ASSERT_THAT(metric.stats.stddev, absl::optional<double>(5.0));
ASSERT_THAT(metric.stats.min, absl::optional<double>(10.0));
ASSERT_THAT(metric.stats.max, absl::optional<double>(20.0));
}
TEST(MetricsLoggerAndExporterTest, LogSingleValueMetricRecordsMultipleMetrics) {
TestMetricsExporterFactory exporter_factory;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters));
logger.LogSingleValueMetric("metric_name1", "test_case_name1",
/*value=*/10, Unit::kMilliseconds,
ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
logger.LogSingleValueMetric("metric_name2", "test_case_name2",
/*value=*/10, Unit::kMilliseconds,
ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
}
std::vector<Metric> metrics = exporter_factory.exported_metrics;
ASSERT_THAT(metrics.size(), Eq(2lu));
EXPECT_THAT(metrics[0].name, Eq("metric_name1"));
EXPECT_THAT(metrics[0].test_case, Eq("test_case_name1"));
EXPECT_THAT(metrics[1].name, Eq("metric_name2"));
EXPECT_THAT(metrics[1].test_case, Eq("test_case_name2"));
}
TEST(MetricsLoggerAndExporterTest,
LogMetricWithSamplesStatsCounterRecordsMultipleMetrics) {
TestMetricsExporterFactory exporter_factory;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters));
SamplesStatsCounter values;
values.AddSample(SamplesStatsCounter::StatsSample{
.value = 10,
.time = Clock::GetRealTimeClock()->CurrentTime(),
.metadata = DefaultMetadata()});
values.AddSample(SamplesStatsCounter::StatsSample{
.value = 20,
.time = Clock::GetRealTimeClock()->CurrentTime(),
.metadata = DefaultMetadata()});
logger.LogMetric("metric_name1", "test_case_name1", values,
Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
logger.LogMetric("metric_name2", "test_case_name2", values,
Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
}
std::vector<Metric> metrics = exporter_factory.exported_metrics;
ASSERT_THAT(metrics.size(), Eq(2lu));
EXPECT_THAT(metrics[0].name, Eq("metric_name1"));
EXPECT_THAT(metrics[0].test_case, Eq("test_case_name1"));
EXPECT_THAT(metrics[1].name, Eq("metric_name2"));
EXPECT_THAT(metrics[1].test_case, Eq("test_case_name2"));
}
TEST(MetricsLoggerAndExporterTest, LogMetricWithStatsRecordsMultipleMetrics) {
TestMetricsExporterFactory exporter_factory;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters));
Metric::Stats metric_stats{.mean = 15, .stddev = 5, .min = 10, .max = 20};
logger.LogMetric("metric_name1", "test_case_name1", metric_stats,
Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
logger.LogMetric("metric_name2", "test_case_name2", metric_stats,
Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
}
std::vector<Metric> metrics = exporter_factory.exported_metrics;
ASSERT_THAT(metrics.size(), Eq(2lu));
EXPECT_THAT(metrics[0].name, Eq("metric_name1"));
EXPECT_THAT(metrics[0].test_case, Eq("test_case_name1"));
EXPECT_THAT(metrics[1].name, Eq("metric_name2"));
EXPECT_THAT(metrics[1].test_case, Eq("test_case_name2"));
}
TEST(MetricsLoggerAndExporterTest,
LogMetricThroughtAllMethodsAccumulateAllMetrics) {
TestMetricsExporterFactory exporter_factory;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters));
SamplesStatsCounter values;
values.AddSample(SamplesStatsCounter::StatsSample{
.value = 10,
.time = Clock::GetRealTimeClock()->CurrentTime(),
.metadata = DefaultMetadata()});
values.AddSample(SamplesStatsCounter::StatsSample{
.value = 20,
.time = Clock::GetRealTimeClock()->CurrentTime(),
.metadata = DefaultMetadata()});
Metric::Stats metric_stats{.mean = 15, .stddev = 5, .min = 10, .max = 20};
logger.LogSingleValueMetric("metric_name1", "test_case_name1",
/*value=*/10, Unit::kMilliseconds,
ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
logger.LogMetric("metric_name2", "test_case_name2", values,
Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
logger.LogMetric("metric_name3", "test_case_name3", metric_stats,
Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
}
std::vector<Metric> metrics = exporter_factory.exported_metrics;
ASSERT_THAT(metrics.size(), Eq(3lu));
EXPECT_THAT(metrics[0].name, Eq("metric_name1"));
EXPECT_THAT(metrics[0].test_case, Eq("test_case_name1"));
EXPECT_THAT(metrics[1].name, Eq("metric_name2"));
EXPECT_THAT(metrics[1].test_case, Eq("test_case_name2"));
EXPECT_THAT(metrics[2].name, Eq("metric_name3"));
EXPECT_THAT(metrics[2].test_case, Eq("test_case_name3"));
}
TEST(MetricsLoggerAndExporterTest,
OneFailedExporterDoesNotPreventExportToOthers) {
TestMetricsExporterFactory exporter_factory1;
TestMetricsExporterFactory exporter_factory2;
TestMetricsExporterFactory exporter_factory3;
{
std::vector<std::unique_ptr<MetricsExporter>> exporters;
exporters.push_back(exporter_factory1.CreateExporter());
exporters.push_back(exporter_factory2.CreateFailureExporter());
exporters.push_back(exporter_factory3.CreateExporter());
MetricsLoggerAndExporter logger(Clock::GetRealTimeClock(),
std::move(exporters),
/*crash_on_export_failure=*/false);
logger.LogSingleValueMetric("metric_name", "test_case_name",
/*value=*/10, Unit::kMilliseconds,
ImprovementDirection::kBiggerIsBetter,
DefaultMetadata());
}
std::vector<Metric> metrics1 = exporter_factory1.exported_metrics;
std::vector<Metric> metrics2 = exporter_factory2.exported_metrics;
std::vector<Metric> metrics3 = exporter_factory3.exported_metrics;
ASSERT_THAT(metrics1.size(), Eq(1lu));
EXPECT_THAT(metrics1[0].name, Eq("metric_name"));
ASSERT_THAT(metrics2.size(), Eq(1lu));
EXPECT_THAT(metrics2[0].name, Eq("metric_name"));
ASSERT_THAT(metrics3.size(), Eq(1lu));
EXPECT_THAT(metrics3[0].name, Eq("metric_name"));
}
} // namespace
} // namespace test
} // namespace webrtc

9
test/pc/e2e/BUILD.gn
View File

@ -514,7 +514,6 @@ if (!build_with_chromium) {
"../../../api/task_queue",
"../../../api/test/metrics:metric",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/units:time_delta",
"../../../api/units:timestamp",
"../../../pc:pc_test_utils",
@ -670,7 +669,6 @@ if (!build_with_chromium) {
"../../../api:network_emulation_manager_api",
"../../../api:peer_connection_quality_test_fixture_api",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/test/metrics:stdout_metrics_exporter",
"../../../api/units:time_delta",
]
@ -762,7 +760,6 @@ if (!build_with_chromium) {
"../../../api:rtp_packet_info",
"../../../api/test/metrics:metric",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/test/metrics:stdout_metrics_exporter",
"../../../api/video:encoded_image",
"../../../api/video:video_frame",
@ -855,7 +852,6 @@ if (!build_with_chromium) {
"../../../api/numerics",
"../../../api/test/metrics:metric",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/units:time_delta",
"../../../api/units:timestamp",
"../../../rtc_base:checks",
@ -904,7 +900,6 @@ if (!build_with_chromium) {
"../../../api/numerics",
"../../../api/test/metrics:metric",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/units:data_rate",
"../../../api/units:data_size",
"../../../api/units:time_delta",
@ -942,7 +937,6 @@ if (!build_with_chromium) {
"../../../api/numerics",
"../../../api/test/metrics:metric",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/units:data_size",
"../../../api/units:time_delta",
"../../../api/units:timestamp",
@ -1054,7 +1048,6 @@ if (!build_with_chromium) {
"../../../api:track_id_stream_info_map",
"../../../api/test/metrics:metric",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/units:data_size",
"../../../rtc_base:checks",
"../../../rtc_base:criticalsection",
@ -1082,7 +1075,6 @@ if (!build_with_chromium) {
"../../../api/numerics",
"../../../api/test/metrics:metric",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/test/network_emulation",
"../../../api/units:data_rate",
"../../../api/units:data_size",
@ -1114,7 +1106,6 @@ if (!build_with_chromium) {
"../../../api/numerics",
"../../../api/test/metrics:metric",
"../../../api/test/metrics:metrics_logger",
"../../../api/test/metrics:metrics_logger_and_exporter",
"../../../api/units:timestamp",
"../../../rtc_base:checks",
"../../../rtc_base:criticalsection",