From 741645a4be3a449c11f868202ea73115d6134c12 Mon Sep 17 00:00:00 2001 From: Adam Stone Date: Tue, 5 Feb 2019 16:33:31 -0800 Subject: [PATCH 1/2] Add UsageTableHeader metrics [ Merge from http://go/wvgerrit/72183 ] Adds basic metrics for the usage table header. Bug: http://b/112919252 Test: Unit tests. Manual GPlay Change-Id: I14d406766d8b2aba3b6e4f1a02c75eedc674b011 --- .../cdm/core/include/usage_table_header.h | 1 + libwvdrmengine/cdm/core/src/cdm_session.cpp | 39 ++-- .../cdm/core/src/crypto_session.cpp | 1 + .../cdm/core/test/cdm_session_unittest.cpp | 2 +- .../cdm/metrics/include/metrics_collections.h | 12 +- libwvdrmengine/cdm/metrics/src/metrics.proto | 11 +- .../cdm/metrics/src/metrics_collections.cpp | 14 +- .../test/metrics_collections_unittest.cpp | 198 +++++++++++++----- .../cdm/test/cdm_extended_duration_test.cpp | 2 +- .../src_hidl/hidl_metrics_adapter.cpp | 19 +- .../test/hidl_metrics_adapter_unittest.cpp | 13 +- 11 files changed, 225 insertions(+), 87 deletions(-) diff --git a/libwvdrmengine/cdm/core/include/usage_table_header.h b/libwvdrmengine/cdm/core/include/usage_table_header.h index bb2f6bb6..f1aadac1 100644 --- a/libwvdrmengine/cdm/core/include/usage_table_header.h +++ b/libwvdrmengine/cdm/core/include/usage_table_header.h @@ -83,6 +83,7 @@ class UsageTableHeader { static int64_t GetRandomInRange(size_t upper_bound_exclusive); static int64_t GetRandomInRangeWithExclusion(size_t upper_bound_exclusive, size_t exclude); + size_t size() { return usage_entry_info_.size(); } private: CdmResponseType MoveEntry(uint32_t from /* usage entry number */, diff --git a/libwvdrmengine/cdm/core/src/cdm_session.cpp b/libwvdrmengine/cdm/core/src/cdm_session.cpp index 8ca04acc..09c8134a 100644 --- a/libwvdrmengine/cdm/core/src/cdm_session.cpp +++ b/libwvdrmengine/cdm/core/src/cdm_session.cpp @@ -267,6 +267,7 @@ CdmResponseType CdmSession::RestoreOfflineSession( } else { CdmResponseType sts = usage_table_header_->LoadEntry( crypto_session_.get(), usage_entry_, usage_entry_number_); + crypto_metrics_->usage_table_header_load_entry_.Increment(sts); if (sts != NO_ERROR) { LOGE( "CdmSession::RestoreOfflineSession: failed to load usage entry = " @@ -298,8 +299,10 @@ CdmResponseType CdmSession::RestoreOfflineSession( if (usage_support_type_ == kUsageEntrySupport && !provider_session_token.empty() && usage_table_header_ != NULL) { - CdmResponseType sts = - usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_); + CdmResponseType sts = NO_ERROR; + M_TIME(sts = usage_table_header_->UpdateEntry(crypto_session_.get(), + &usage_entry_), + crypto_metrics_, usage_table_header_update_entry_, sts); if (sts != NO_ERROR) { LOGE( "CdmSession::RestoreOfflineSession failed to update usage entry = " @@ -341,6 +344,7 @@ CdmResponseType CdmSession::RestoreUsageSession( usage_table_header_ != NULL) { sts = usage_table_header_->LoadEntry( crypto_session_.get(), usage_entry_, usage_entry_number_); + crypto_metrics_->usage_table_header_load_entry_.Increment(sts); if (sts != NO_ERROR) { LOGE("CdmSession::RestoreUsageSession: failed to load usage entry = %d", sts); @@ -357,8 +361,9 @@ CdmResponseType CdmSession::RestoreUsageSession( if (usage_support_type_ == kUsageEntrySupport && usage_table_header_ != NULL) { - sts = - usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_); + M_TIME(sts = usage_table_header_->UpdateEntry(crypto_session_.get(), + &usage_entry_), + crypto_metrics_, usage_table_header_update_entry_, sts); if (sts != NO_ERROR) { LOGE("CdmSession::RestoreUsageSession: failed to update usage entry: %d", sts); @@ -504,6 +509,7 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) { sts = usage_table_header_->AddEntry( crypto_session_.get(), is_offline_, key_set_id_, DeviceFiles::GetUsageInfoFileName(app_id), &usage_entry_number_); + crypto_metrics_->usage_table_header_add_entry_.Increment(sts); if (sts != NO_ERROR) return sts; } } @@ -515,6 +521,7 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) { if (sts != KEY_ADDED) { CdmResponseType delete_sts = usage_table_header_->DeleteEntry( usage_entry_number_, file_handle_.get(), crypto_metrics_); + crypto_metrics_->usage_table_header_delete_entry_.Increment(delete_sts); if (delete_sts != NO_ERROR) { LOGW("CdmSession::AddKey: Delete usage entry failed = %d", delete_sts); @@ -535,7 +542,9 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) { if (has_provider_session_token() && usage_support_type_ == kUsageEntrySupport && usage_table_header_ != NULL) { - usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_); + M_TIME(sts = usage_table_header_->UpdateEntry(crypto_session_.get(), + &usage_entry_), + crypto_metrics_, usage_table_header_update_entry_, sts); } if (!is_offline_) @@ -710,8 +719,9 @@ CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyRequest* key_request) { if (has_provider_session_token() && usage_support_type_ == kUsageEntrySupport) { - status = - usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_); + M_TIME(status = usage_table_header_->UpdateEntry(crypto_session_.get(), + &usage_entry_), + crypto_metrics_, usage_table_header_update_entry_, status); if (status != NO_ERROR) { LOGE( "CdmSession::GenerateReleaseRequest: Update usage entry failed = " @@ -785,8 +795,10 @@ CdmResponseType CdmSession::DeleteUsageEntry(uint32_t usage_entry_number) { return INCORRECT_USAGE_SUPPORT_TYPE_1; } - return usage_table_header_->DeleteEntry(usage_entry_number, - file_handle_.get(), crypto_metrics_); + sts = usage_table_header_->DeleteEntry(usage_entry_number, + file_handle_.get(), crypto_metrics_); + crypto_metrics_->usage_table_header_delete_entry_.Increment(sts); + return sts; } bool CdmSession::IsKeyLoaded(const KeyId& key_id) { @@ -1025,12 +1037,9 @@ CdmResponseType CdmSession::UpdateUsageEntryInformation() { } CdmResponseType sts = NO_ERROR; - M_TIME( - sts = usage_table_header_->UpdateEntry(crypto_session_.get(), - &usage_entry_), - crypto_metrics_, - crypto_session_update_usage_entry_, - sts); + M_TIME(sts = usage_table_header_->UpdateEntry(crypto_session_.get(), + &usage_entry_), + crypto_metrics_, usage_table_header_update_entry_, sts); if (sts != NO_ERROR) return sts; diff --git a/libwvdrmengine/cdm/core/src/crypto_session.cpp b/libwvdrmengine/cdm/core/src/crypto_session.cpp index 5e736b7b..6f7bf236 100644 --- a/libwvdrmengine/cdm/core/src/crypto_session.cpp +++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp @@ -859,6 +859,7 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) { } } usage_table_header_ = *header; + metrics_->usage_table_header_initial_size_.Record((*header)->size()); } } } diff --git a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp index f7cb1827..6633bf43 100644 --- a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp @@ -361,7 +361,7 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) { std::string serialized_metrics; ASSERT_TRUE(metrics.SerializeToString(&serialized_metrics)); EXPECT_GT(metrics.crypto_metrics() - .crypto_session_update_usage_entry_time_us().size(), 0) + .usage_table_header_update_entry_time_us().size(), 0) << "Missing update usage entry metric. Metrics: " << wvcdm::b2a_hex(serialized_metrics); } diff --git a/libwvdrmengine/cdm/metrics/include/metrics_collections.h b/libwvdrmengine/cdm/metrics/include/metrics_collections.h index ba684610..6feb0518 100644 --- a/libwvdrmengine/cdm/metrics/include/metrics_collections.h +++ b/libwvdrmengine/cdm/metrics/include/metrics_collections.h @@ -161,9 +161,17 @@ class CryptoMetrics { ValueMetric crypto_session_system_id_; EventMetric crypto_session_update_usage_information_; - EventMetric - crypto_session_update_usage_entry_; ValueMetric crypto_session_usage_information_support_; + /* UsageTableHeader */ + CounterMetric + usage_table_header_add_entry_; + CounterMetric + usage_table_header_delete_entry_; + CounterMetric + usage_table_header_load_entry_; + EventMetric + usage_table_header_update_entry_; + ValueMetric usage_table_header_initial_size_; /* OEMCRYPTO */ ValueMetric oemcrypto_api_version_; CounterMetric diff --git a/libwvdrmengine/cdm/metrics/src/metrics.proto b/libwvdrmengine/cdm/metrics/src/metrics.proto index f1aa60aa..37020ac5 100644 --- a/libwvdrmengine/cdm/metrics/src/metrics.proto +++ b/libwvdrmengine/cdm/metrics/src/metrics.proto @@ -94,7 +94,7 @@ message WvCdmMetrics { // This contains metrics that were captured at the CryptoSession level. These // include CryptoSession metrics and most OEMCrypto metrics. - // next id: 58 + // next id: 62 message CryptoMetrics { // Crypto Session Metrics. optional ValueMetric crypto_session_security_level = 1; @@ -111,8 +111,15 @@ message WvCdmMetrics { repeated DistributionMetric crypto_session_open_time_us = 12; optional ValueMetric crypto_session_system_id = 13; repeated DistributionMetric crypto_session_update_usage_information_time_us = 14; - repeated DistributionMetric crypto_session_update_usage_entry_time_us = 56; optional ValueMetric crypto_session_usage_information_support = 15; + + // Usage Table Metrics + optional ValueMetric usage_table_header_initial_size = 58; + repeated CounterMetric usage_table_header_add_entry = 59; + repeated CounterMetric usage_table_header_delete_entry = 60; + repeated DistributionMetric usage_table_header_update_entry_time_us = 56; + repeated CounterMetric usage_table_header_load_entry = 61; + // OemCrypto metrics. optional ValueMetric oemcrypto_api_version = 16; repeated CounterMetric oemcrypto_close_session = 17; diff --git a/libwvdrmengine/cdm/metrics/src/metrics_collections.cpp b/libwvdrmengine/cdm/metrics/src/metrics_collections.cpp index afa301af..5501a99a 100644 --- a/libwvdrmengine/cdm/metrics/src/metrics_collections.cpp +++ b/libwvdrmengine/cdm/metrics/src/metrics_collections.cpp @@ -65,11 +65,21 @@ void CryptoMetrics::Serialize(WvCdmMetrics::CryptoMetrics *crypto_metrics) crypto_session_update_usage_information_.ToProto( crypto_metrics ->mutable_crypto_session_update_usage_information_time_us()); - crypto_session_update_usage_entry_.ToProto( - crypto_metrics->mutable_crypto_session_update_usage_entry_time_us()); crypto_metrics->set_allocated_crypto_session_usage_information_support( crypto_session_usage_information_support_.ToProto()); + /* USAGE TABLE HEADER */ + usage_table_header_add_entry_.ToProto( + crypto_metrics->mutable_usage_table_header_add_entry()); + usage_table_header_delete_entry_.ToProto( + crypto_metrics->mutable_usage_table_header_delete_entry()); + usage_table_header_update_entry_.ToProto( + crypto_metrics->mutable_usage_table_header_update_entry_time_us()); + usage_table_header_load_entry_.ToProto( + crypto_metrics->mutable_usage_table_header_load_entry()); + crypto_metrics->set_allocated_usage_table_header_initial_size( + usage_table_header_initial_size_.ToProto()); + /* OEMCRYPTO */ crypto_metrics->set_allocated_oemcrypto_api_version( oemcrypto_api_version_.ToProto()); diff --git a/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp b/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp index d07d22ff..f88e8bef 100644 --- a/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp +++ b/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp @@ -13,10 +13,10 @@ #include "gtest/gtest.h" #include "log.h" #include "metrics.pb.h" +#include "string_conversions.h" #include "wv_cdm_types.h" using drm_metrics::WvCdmMetrics; -using google::protobuf::TextFormat; namespace { const char kSessionId1[] = "session_id_1"; @@ -35,12 +35,14 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) { EngineMetrics engine_metrics; // Set some values in all of the engine metrics. - engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease); + engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, + kLicenseTypeRelease); engine_metrics.cdm_engine_close_session_.Increment(NO_ERROR); engine_metrics.cdm_engine_decrypt_.Record(1.0, NO_ERROR, metrics::Pow2Bucket(8)); engine_metrics.cdm_engine_find_session_for_key_.Increment(false); - engine_metrics.cdm_engine_generate_key_request_.Record(1.0, NO_ERROR, kLicenseTypeRelease); + engine_metrics.cdm_engine_generate_key_request_.Record(1.0, NO_ERROR, + kLicenseTypeRelease); engine_metrics.cdm_engine_get_provisioning_request_.Record(1.0, NO_ERROR); engine_metrics.cdm_engine_get_usage_info_.Record(1.0, NO_ERROR, UNKNOWN_ERROR); @@ -53,6 +55,12 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) { engine_metrics.cdm_engine_remove_keys_.Increment(NO_ERROR); engine_metrics.cdm_engine_restore_key_.Record(1.0, NO_ERROR); engine_metrics.cdm_engine_unprovision_.Increment(NO_ERROR, kSecurityLevelL1); + engine_metrics.SetAppPackageName("test package name"); + engine_metrics.cdm_engine_cdm_version_.Record("test cdm version"); + engine_metrics.cdm_engine_creation_time_millis_.Record(100); + engine_metrics.cdm_engine_get_secure_stop_ids_.Increment(UNKNOWN_ERROR); + engine_metrics.cdm_engine_remove_all_usage_info_.Increment(UNKNOWN_ERROR); + engine_metrics.cdm_engine_remove_usage_info_.Increment(UNKNOWN_ERROR); // Also set and serialize the oemcrypto dynamic adapter metrics. OemCryptoDynamicAdapterMetrics adapter_metrics; @@ -60,48 +68,54 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) { adapter_metrics.SetL1ApiVersion(2); adapter_metrics.SetL1MinApiVersion(1); - WvCdmMetrics actual_metrics; - engine_metrics.Serialize(&actual_metrics); - adapter_metrics.Serialize(actual_metrics.mutable_engine_metrics()); + WvCdmMetrics actual; + engine_metrics.Serialize(&actual); + adapter_metrics.Serialize(actual.mutable_engine_metrics()); - ASSERT_TRUE(actual_metrics.has_engine_metrics()); - EXPECT_EQ(0, actual_metrics.session_metrics_size()); - - // Spot check some metrics. - ASSERT_EQ(1, - actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size()); - EXPECT_EQ(2, actual_metrics.engine_metrics() - .cdm_engine_add_key_time_us(0) - .attributes().error_code()); - ASSERT_EQ(1, - actual_metrics.engine_metrics().cdm_engine_close_session_size()); - EXPECT_EQ(0, actual_metrics.engine_metrics() - .cdm_engine_close_session(0) - .attributes().error_code()); - ASSERT_EQ(1, - actual_metrics.engine_metrics().cdm_engine_decrypt_time_us_size()); - EXPECT_EQ(0, actual_metrics.engine_metrics() - .cdm_engine_decrypt_time_us(0) - .attributes().error_code()); - EXPECT_EQ(1.0, actual_metrics.engine_metrics() - .cdm_engine_decrypt_time_us(0) - .mean()); - EXPECT_EQ(OEMCrypto_INITIALIZED_FORCING_L3, - actual_metrics.engine_metrics().oemcrypto_initialization_mode() - .int_value()); - ASSERT_EQ( - 1, actual_metrics.engine_metrics() - .cdm_engine_get_usage_info_time_us_size()); - - EXPECT_EQ(UNKNOWN_ERROR, actual_metrics.engine_metrics() - .cdm_engine_get_usage_info_time_us(0).attributes().error_detail()); + EXPECT_EQ(0, actual.session_metrics_size()); + ASSERT_TRUE(actual.has_engine_metrics()); + EXPECT_GT(actual.engine_metrics().cdm_engine_add_key_time_us_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_decrypt_time_us_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_find_session_for_key_size(), 0); + EXPECT_GT( + actual.engine_metrics() + .cdm_engine_generate_key_request_time_us_size(), 0); + EXPECT_GT( + actual.engine_metrics() + .cdm_engine_get_provisioning_request_time_us_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_get_usage_info_time_us_size(), + 0); + EXPECT_GT( + actual.engine_metrics() + .cdm_engine_handle_provisioning_response_time_us_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_open_key_set_session_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_open_session_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_query_key_status_time_us_size(), + 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_release_all_usage_info_size(), + 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_release_usage_info_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_remove_keys_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_restore_key_time_us_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_unprovision_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_get_secure_stop_ids_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_remove_all_usage_info_size(), 0); + EXPECT_GT(actual.engine_metrics().cdm_engine_remove_usage_info_size(), 0); + EXPECT_EQ("test package name", + actual.engine_metrics().app_package_name().string_value()); + EXPECT_EQ("test cdm version", + actual.engine_metrics().cdm_engine_cdm_version().string_value()); + EXPECT_EQ(100, + actual.engine_metrics() + .cdm_engine_creation_time_millis().int_value()); } TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) { EngineMetrics engine_metrics; // Set some values in some of the engine metrics and some crypto metrics. - engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease); + engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, + kLicenseTypeRelease); engine_metrics.cdm_engine_close_session_.Increment(UNKNOWN_ERROR); CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics(); @@ -159,7 +173,8 @@ TEST_F(EngineMetricsTest, EngineMetricsWithSessions) { EngineMetrics engine_metrics; // Set a values in an engine metric and in a crypto metric. - engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease); + engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, + kLicenseTypeRelease); engine_metrics.GetCryptoMetrics() ->crypto_session_load_certificate_private_key_.Record(2.0, NO_ERROR); @@ -258,23 +273,24 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) { NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized); session_metrics.cdm_session_license_request_latency_ms_.Record( 2.0, kKeyRequestTypeInitial); + session_metrics.oemcrypto_build_info_.Record("test build info"); // Record a CryptoMetrics metric in the session. session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_ .Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); - WvCdmMetrics::SessionMetrics actual_metrics; - session_metrics.Serialize(&actual_metrics); - - // Spot check metrics. - EXPECT_STREQ(kSessionId1, - actual_metrics.session_id().string_value().c_str()); - EXPECT_EQ(1.0, actual_metrics.cdm_session_life_span_ms().double_value()); - EXPECT_EQ(1, actual_metrics.cdm_session_renew_key_time_us_size()); - EXPECT_EQ(1, actual_metrics.cdm_session_restore_offline_session_size()); - EXPECT_EQ(1, actual_metrics.cdm_session_restore_usage_session_size()); - EXPECT_EQ(1, actual_metrics.crypto_metrics() - .crypto_session_generic_decrypt_time_us_size()); + WvCdmMetrics::SessionMetrics actual; + session_metrics.Serialize(&actual); + EXPECT_STREQ(kSessionId1, actual.session_id().string_value().c_str()); + EXPECT_EQ(1.0, actual.cdm_session_life_span_ms().double_value()); + EXPECT_GT(actual.cdm_session_renew_key_time_us_size(), 0); + EXPECT_GT(actual.cdm_session_restore_offline_session_size(), 0); + EXPECT_GT(actual.cdm_session_restore_usage_session_size(), 0); + EXPECT_GT(actual.cdm_session_license_request_latency_ms_size(), 0); + EXPECT_STREQ("test build info", + actual.oemcrypto_build_info().string_value().c_str()); + EXPECT_GT( + actual.crypto_metrics().crypto_session_generic_decrypt_time_us_size(), 0); } TEST_F(SessionMetricsTest, EmptySessionMetrics) { @@ -320,6 +336,13 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) { crypto_metrics.crypto_session_usage_information_support_.Record(true); crypto_metrics.crypto_session_security_level_.Record(kSecurityLevelL2); + // Usage table header metrics. + crypto_metrics.usage_table_header_initial_size_.Record(200); + crypto_metrics.usage_table_header_add_entry_.Increment(UNKNOWN_ERROR); + crypto_metrics.usage_table_header_delete_entry_.Increment(UNKNOWN_ERROR); + crypto_metrics.usage_table_header_update_entry_.Record(2.0, UNKNOWN_ERROR); + crypto_metrics.usage_table_header_load_entry_.Increment(UNKNOWN_ERROR); + // Oem crypto metrics. crypto_metrics.oemcrypto_api_version_.Record(123); crypto_metrics.oemcrypto_close_session_ @@ -385,14 +408,73 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) { crypto_metrics.oemcrypto_update_usage_table_ .Increment(OEMCrypto_ERROR_INIT_FAILED); - WvCdmMetrics::CryptoMetrics actual_metrics; - crypto_metrics.Serialize(&actual_metrics); + WvCdmMetrics::CryptoMetrics actual; + crypto_metrics.Serialize(&actual); - // Spot check some metrics. - EXPECT_EQ(1, actual_metrics.crypto_session_delete_all_usage_reports_size()); - EXPECT_EQ(1, actual_metrics.crypto_session_delete_all_usage_reports_size()); - EXPECT_EQ(123, actual_metrics.oemcrypto_api_version().int_value()); - EXPECT_EQ(1, actual_metrics.oemcrypto_generic_sign_time_us_size()); + // Crypto session metrics. + EXPECT_GT(actual.crypto_session_delete_all_usage_reports_size(), 0); + EXPECT_GT(actual.crypto_session_delete_multiple_usage_information_size(), 0); + EXPECT_GT(actual.crypto_session_generic_decrypt_time_us_size(), 0); + EXPECT_GT(actual.crypto_session_generic_encrypt_time_us_size(), 0); + EXPECT_GT(actual.crypto_session_generic_sign_time_us_size(), 0); + EXPECT_GT(actual.crypto_session_generic_verify_time_us_size(), 0); + EXPECT_GT(actual.crypto_session_get_device_unique_id_size(), 0); + EXPECT_GT(actual.crypto_session_get_token_size(), 0); + EXPECT_EQ(1.0, actual.crypto_session_life_span().double_value()); + EXPECT_GT(actual.crypto_session_load_certificate_private_key_time_us_size(), + 0); + EXPECT_GT(actual.crypto_session_open_time_us_size(), 0); + EXPECT_GT(actual.crypto_session_update_usage_information_time_us_size(), 0); + EXPECT_EQ(true, + actual.crypto_session_usage_information_support().int_value()); + EXPECT_EQ(kSecurityLevelL2, + actual.crypto_session_security_level().int_value()); + + // Usage table header metrics. + EXPECT_EQ(200, actual.usage_table_header_initial_size().int_value()); + EXPECT_GT(actual.usage_table_header_add_entry_size(), 0); + EXPECT_GT(actual.usage_table_header_delete_entry_size(), 0); + EXPECT_GT(actual.usage_table_header_update_entry_time_us_size(), 0); + EXPECT_GT(actual.usage_table_header_load_entry_size(), 0); + + // Oem crypto metrics. + EXPECT_EQ(123, actual.oemcrypto_api_version().int_value()); + EXPECT_GT(actual.oemcrypto_close_session_size(), 0); + EXPECT_GT(actual.oemcrypto_copy_buffer_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_deactivate_usage_entry_size(), 0); + EXPECT_GT(actual.oemcrypto_decrypt_cenc_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_delete_usage_entry_size(), 0); + EXPECT_GT(actual.oemcrypto_delete_usage_table_size(), 0); + EXPECT_GT(actual.oemcrypto_derive_keys_from_session_key_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_force_delete_usage_entry_size(), 0); + EXPECT_GT(actual.oemcrypto_generate_derived_keys_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_generate_nonce_size(), 0); + EXPECT_GT(actual.oemcrypto_generate_rsa_signature_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_generate_signature_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_generic_decrypt_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_generic_encrypt_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_generic_sign_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_generic_verify_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_get_device_id_size(), 0); + EXPECT_GT(actual.oemcrypto_get_key_data_time_us_size(), 0); + EXPECT_EQ(7, actual.oemcrypto_max_number_of_sessions().int_value()); + EXPECT_EQ(5, actual.oemcrypto_number_of_open_sessions().int_value()); + EXPECT_GT(actual.oemcrypto_get_oem_public_certificate_size(), 0); + EXPECT_EQ(OEMCrypto_Keybox, + actual.oemcrypto_provisioning_method().int_value()); + EXPECT_GT(actual.oemcrypto_get_random_size(), 0); + EXPECT_GT(actual.oemcrypto_initialize_time_us_size(), 0); + EXPECT_EQ(true, actual.oemcrypto_is_anti_rollback_hw_present().int_value()); + EXPECT_EQ(true, actual.oemcrypto_is_keybox_valid().int_value()); + EXPECT_GT(actual.oemcrypto_load_device_rsa_key_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_load_keys_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_refresh_keys_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_report_usage_size(), 0); + EXPECT_GT(actual.oemcrypto_rewrap_device_rsa_key_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_rewrap_device_rsa_key_30_time_us_size(), 0); + EXPECT_EQ(123, actual.oemcrypto_security_patch_level().int_value()); + EXPECT_GT(actual.oemcrypto_select_key_time_us_size(), 0); + EXPECT_GT(actual.oemcrypto_update_usage_table_size(), 0); } } // namespace metrics diff --git a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp index 7e57fe7e..563cbf37 100644 --- a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp +++ b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp @@ -627,7 +627,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { for (const auto& session : metrics.session_metrics()) { has_update_usage_entry_metrics |= session.crypto_metrics() - .crypto_session_update_usage_entry_time_us().size() > 0; + .usage_table_header_update_entry_time_us().size() > 0; has_update_usage_entry_metrics |= session.crypto_metrics().oemcrypto_update_usage_entry().size() > 0; } diff --git a/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp b/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp index 75febd26..6ed91e12 100644 --- a/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp +++ b/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp @@ -454,13 +454,26 @@ void HidlMetricsAdapter::AddCryptoMetrics( group_builder->AddDistributions( "crypto_session_update_usage_information_time_us", proto_metrics.crypto_session_update_usage_information_time_us()); - group_builder->AddDistributions( - "crypto_session_update_usage_entry_time_us", - proto_metrics.crypto_session_update_usage_entry_time_us()); if (proto_metrics.has_crypto_session_usage_information_support()) { group_builder->AddValue("crypto_session_usage_information_support", proto_metrics.crypto_session_usage_information_support()); } + if (proto_metrics.has_usage_table_header_initial_size()) { + group_builder->AddValue("usage_table_header_initial_size", + proto_metrics.usage_table_header_initial_size()); + } + group_builder->AddCounters( + "usage_table_header_add_entry", + proto_metrics.usage_table_header_add_entry()); + group_builder->AddCounters( + "usage_table_header_delete_entry", + proto_metrics.usage_table_header_delete_entry()); + group_builder->AddDistributions( + "usage_table_header_update_entry_time_us", + proto_metrics.usage_table_header_update_entry_time_us()); + group_builder->AddCounters( + "usage_table_header_load_entry", + proto_metrics.usage_table_header_load_entry()); if (proto_metrics.has_oemcrypto_api_version()) { group_builder->AddValue("oemcrypto_api_version", proto_metrics.oemcrypto_api_version()); diff --git a/libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp b/libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp index f30807ae..5020ccb7 100644 --- a/libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp +++ b/libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp @@ -340,9 +340,16 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) { crypto_metrics.mutable_crypto_session_system_id()->set_int_value(1); crypto_metrics.add_crypto_session_update_usage_information_time_us ()->set_min(1.0f); - crypto_metrics.add_crypto_session_update_usage_entry_time_us()->set_min(1.0f); crypto_metrics.mutable_crypto_session_usage_information_support ()->set_int_value(1); + + // Usage Table Metrics + crypto_metrics.mutable_usage_table_header_initial_size()->set_int_value(1); + crypto_metrics.add_usage_table_header_add_entry()->set_count(13); + crypto_metrics.add_usage_table_header_delete_entry()->set_count(13); + crypto_metrics.add_usage_table_header_update_entry_time_us()->set_min(1.0f); + crypto_metrics.add_usage_table_header_load_entry()->set_count(13); + // OemCrypto metrics. crypto_metrics.mutable_oemcrypto_api_version()->set_int_value(1); crypto_metrics.add_oemcrypto_close_session()->set_count(13); @@ -443,8 +450,8 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) { hidl_vec hidl_metrics; HidlMetricsAdapter::ToHidlMetrics(metrics_proto, &hidl_metrics); ASSERT_EQ(2U, hidl_metrics.size()); - EXPECT_EQ(85U, hidl_metrics[0].metrics.size()) << ToString(hidl_metrics); - EXPECT_EQ(64U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics); + EXPECT_EQ(89U, hidl_metrics[0].metrics.size()) << ToString(hidl_metrics); + EXPECT_EQ(68U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics); } } // namespace wvcdm From c891824a7a5783b0d9b2bc11022f43498254f5dc Mon Sep 17 00:00:00 2001 From: Adam Stone Date: Thu, 14 Feb 2019 17:10:19 -0800 Subject: [PATCH 2/2] Adds a VersionInfo message to SignedMessage [ Merge from http://go/wvgerrit/72724 ] This adds a message that contains SDK and service version information useful for debugging problems that occur because of different services. BUG: 80536436 Test: Unit tests and manual GPlay testing. Change-Id: I095f893b907ea7c2cd149155fb2cd4c7181e7bb2 --- libwvdrmengine/cdm/core/include/license.h | 9 +++++++++ libwvdrmengine/cdm/core/src/cdm_session.cpp | 5 +++++ libwvdrmengine/cdm/core/src/license.cpp | 5 +++++ libwvdrmengine/cdm/core/src/license_protocol.proto | 10 ++++++++++ .../cdm/metrics/include/metrics_collections.h | 2 ++ libwvdrmengine/cdm/metrics/src/metrics.proto | 2 ++ libwvdrmengine/cdm/metrics/src/metrics_collections.cpp | 4 ++++ .../cdm/metrics/test/metrics_collections_unittest.cpp | 6 ++++++ .../mediadrm/src_hidl/hidl_metrics_adapter.cpp | 10 ++++++++++ .../mediadrm/test/hidl_metrics_adapter_unittest.cpp | 4 +++- 10 files changed, 56 insertions(+), 1 deletion(-) diff --git a/libwvdrmengine/cdm/core/include/license.h b/libwvdrmengine/cdm/core/include/license.h index 89d2604b..91b9708d 100644 --- a/libwvdrmengine/cdm/core/include/license.h +++ b/libwvdrmengine/cdm/core/include/license.h @@ -17,6 +17,7 @@ namespace video_widevine { class SignedMessage; class LicenseRequest; +class VersionInfo; } // namespace video_widevine namespace wvcdm { @@ -29,6 +30,7 @@ class CryptoKey; using ::google::protobuf::RepeatedPtrField; using video_widevine::License_KeyContainer; +using video_widevine::VersionInfo; using video_widevine::WidevinePsshData_EntitledKey; class CdmLicense { @@ -75,6 +77,10 @@ class CdmLicense { virtual bool is_offline() { return is_offline_; } + virtual const VersionInfo& GetServiceVersion() { + return latest_service_version_; + } + static bool ExtractProviderSessionToken( const CdmKeyResponse& license_response, std::string* provider_session_token); @@ -152,6 +158,9 @@ class CdmLicense { RepeatedPtrField entitlement_keys_; std::string provider_client_token_; + // This is the latest version info extracted from the SignedMessage in + // HandleKeyResponse + VersionInfo latest_service_version_; #if defined(UNIT_TEST) friend class CdmLicenseTestPeer; diff --git a/libwvdrmengine/cdm/core/src/cdm_session.cpp b/libwvdrmengine/cdm/core/src/cdm_session.cpp index 09c8134a..f10e98b3 100644 --- a/libwvdrmengine/cdm/core/src/cdm_session.cpp +++ b/libwvdrmengine/cdm/core/src/cdm_session.cpp @@ -515,6 +515,11 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) { } sts = license_parser_->HandleKeyResponse(key_response); + // Update the license sdk and service versions. + const VersionInfo& version_info = license_parser_->GetServiceVersion(); + metrics_->license_sdk_version_.Record(version_info.license_sdk_version()); + metrics_->license_sdk_version_.Record(version_info.license_service_version()); + // Update or delete entry if usage table header+entries are supported if (usage_support_type_ == kUsageEntrySupport && !provider_session_token.empty() && usage_table_header_ != NULL) { diff --git a/libwvdrmengine/cdm/core/src/license.cpp b/libwvdrmengine/cdm/core/src/license.cpp index 22bd78c2..39214299 100644 --- a/libwvdrmengine/cdm/core/src/license.cpp +++ b/libwvdrmengine/cdm/core/src/license.cpp @@ -514,6 +514,9 @@ CdmResponseType CdmLicense::HandleKeyResponse( LOGE("CdmLicense::HandleKeyResponse: not initialized"); return LICENSE_PARSER_NOT_INITIALIZED_2; } + // Clear the latest service version when we receive a new response. + latest_service_version_.Clear(); + if (license_response.empty()) { LOGE("CdmLicense::HandleKeyResponse: empty license response"); return EMPTY_LICENSE_RESPONSE_1; @@ -527,6 +530,8 @@ CdmResponseType CdmLicense::HandleKeyResponse( return INVALID_LICENSE_RESPONSE; } + latest_service_version_ = signed_response.service_version_info(); + if (use_privacy_mode_ && Properties::allow_service_certificate_requests() && signed_response.type() == SignedMessage::SERVICE_CERTIFICATE) { std::string signed_certificate; diff --git a/libwvdrmengine/cdm/core/src/license_protocol.proto b/libwvdrmengine/cdm/core/src/license_protocol.proto index 883b54ac..a9b0c719 100644 --- a/libwvdrmengine/cdm/core/src/license_protocol.proto +++ b/libwvdrmengine/cdm/core/src/license_protocol.proto @@ -390,6 +390,13 @@ message RemoteAttestation { optional bytes signature = 3; } +message VersionInfo { + // License SDK version reported by the Widevine License SDK. + optional string license_sdk_version = 1; + // Version of the service hosting the license SDK. + optional string license_service_version = 2; +} + message SignedMessage { enum MessageType { LICENSE_REQUEST = 1; @@ -412,6 +419,9 @@ message SignedMessage { optional RemoteAttestation remote_attestation = 5; repeated MetricData metric_data = 6; + // Version information from the SDK and license service. This information is + // provided in the license response. + optional VersionInfo service_version_info = 7; } message GroupKeys { enum GroupLicenseVersion { diff --git a/libwvdrmengine/cdm/metrics/include/metrics_collections.h b/libwvdrmengine/cdm/metrics/include/metrics_collections.h index 6feb0518..b80233f7 100644 --- a/libwvdrmengine/cdm/metrics/include/metrics_collections.h +++ b/libwvdrmengine/cdm/metrics/include/metrics_collections.h @@ -296,6 +296,8 @@ class SessionMetrics { EventMetric cdm_session_license_request_latency_ms_; ValueMetric oemcrypto_build_info_; + ValueMetric license_sdk_version_; + ValueMetric license_service_version_; // Serialize the session metrics to the provided |metric_group|. // |metric_group| is owned by the caller and must not be null. diff --git a/libwvdrmengine/cdm/metrics/src/metrics.proto b/libwvdrmengine/cdm/metrics/src/metrics.proto index 37020ac5..e7caa567 100644 --- a/libwvdrmengine/cdm/metrics/src/metrics.proto +++ b/libwvdrmengine/cdm/metrics/src/metrics.proto @@ -176,6 +176,8 @@ message WvCdmMetrics { repeated CounterMetric cdm_session_restore_usage_session = 6; repeated DistributionMetric cdm_session_license_request_latency_ms = 7; optional ValueMetric oemcrypto_build_info = 8; + optional ValueMetric license_sdk_version = 9; + optional ValueMetric license_service_version = 10; } // These are metrics recorded at the Engine level. This includes CryptoSession diff --git a/libwvdrmengine/cdm/metrics/src/metrics_collections.cpp b/libwvdrmengine/cdm/metrics/src/metrics_collections.cpp index 5501a99a..e6f4093f 100644 --- a/libwvdrmengine/cdm/metrics/src/metrics_collections.cpp +++ b/libwvdrmengine/cdm/metrics/src/metrics_collections.cpp @@ -191,6 +191,10 @@ void SessionMetrics::SerializeSessionMetrics( session_metrics->mutable_cdm_session_license_request_latency_ms()); session_metrics->set_allocated_oemcrypto_build_info( oemcrypto_build_info_.ToProto()); + session_metrics->set_allocated_license_sdk_version( + license_sdk_version_.ToProto()); + session_metrics->set_allocated_license_service_version( + license_service_version_.ToProto()); } OemCryptoDynamicAdapterMetrics::OemCryptoDynamicAdapterMetrics() diff --git a/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp b/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp index f88e8bef..52abd85e 100644 --- a/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp +++ b/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp @@ -274,6 +274,8 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) { session_metrics.cdm_session_license_request_latency_ms_.Record( 2.0, kKeyRequestTypeInitial); session_metrics.oemcrypto_build_info_.Record("test build info"); + session_metrics.license_sdk_version_.Record("test license sdk version"); + session_metrics.license_service_version_.Record("test license service version"); // Record a CryptoMetrics metric in the session. session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_ @@ -289,6 +291,10 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) { EXPECT_GT(actual.cdm_session_license_request_latency_ms_size(), 0); EXPECT_STREQ("test build info", actual.oemcrypto_build_info().string_value().c_str()); + EXPECT_STREQ("test license sdk version", + actual.license_sdk_version().string_value().c_str()); + EXPECT_STREQ("test license service version", + actual.license_service_version().string_value().c_str()); EXPECT_GT( actual.crypto_metrics().crypto_session_generic_decrypt_time_us_size(), 0); } diff --git a/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp b/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp index 6ed91e12..679a55db 100644 --- a/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp +++ b/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp @@ -402,6 +402,16 @@ void HidlMetricsAdapter::AddSessionMetrics( "oemcrypto_build_info", proto_metrics.oemcrypto_build_info()); } + if (proto_metrics.has_license_sdk_version()) { + group_builder.AddValue( + "license_sdk_version", + proto_metrics.license_sdk_version()); + } + if (proto_metrics.has_license_service_version()) { + group_builder.AddValue( + "license_service_version", + proto_metrics.license_service_version()); + } group_vector_.emplace_back(group_builder.Build()); } diff --git a/libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp b/libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp index 5020ccb7..cf923deb 100644 --- a/libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp +++ b/libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp @@ -405,6 +405,8 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) { session_metrics.add_cdm_session_restore_usage_session()->set_count(13); session_metrics.add_cdm_session_license_request_latency_ms()->set_min(1.0); session_metrics.mutable_oemcrypto_build_info()->set_string_value("test"); + session_metrics.mutable_license_sdk_version()->set_string_value("test sdk"); + session_metrics.mutable_license_service_version()->set_string_value("test service"); drm_metrics::WvCdmMetrics::EngineMetrics engine_metrics; *(engine_metrics.mutable_crypto_metrics()) = crypto_metrics; @@ -451,7 +453,7 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) { HidlMetricsAdapter::ToHidlMetrics(metrics_proto, &hidl_metrics); ASSERT_EQ(2U, hidl_metrics.size()); EXPECT_EQ(89U, hidl_metrics[0].metrics.size()) << ToString(hidl_metrics); - EXPECT_EQ(68U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics); + EXPECT_EQ(70U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics); } } // namespace wvcdm