widevine-partner/ce_cdm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Source release 15.0.0

Browse Source
This commit is contained in:
John W. Bruce
2019-02-28 16:25:30 -08:00
parent f51edaba5a
commit 66628486b5
2672 changed files with 260431 additions and 762489 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
metrics/include/counter_metric.h
View File

@@ -8,12 +8,12 @@
#include <cstdarg>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
#include "attribute_handler.h"
#include "field_tuples.h"
#include "lock.h"
namespace wvcdm {
namespace metrics {
@@ -51,7 +51,7 @@ class BaseCounterMetric {
* across multiple threads preventing the caller from worrying about
* locking.
*/
Lock internal_lock_;
std::mutex internal_lock_;
};
// The CounterMetric class is used to track a counter such as the number of

5
metrics/include/event_metric.h
View File

@@ -7,17 +7,16 @@
#include <cstdarg>
#include <map>
#include <mutex>
#include <string>
#include <vector>
#include "OEMCryptoCENC.h"
#include "attribute_handler.h"
#include "distribution.h"
#include "lock.h"
#include "log.h"
#include "metrics.pb.h"
#include "pow2bucket.h"
#include "shared_ptr.h"
namespace wvcdm {
namespace metrics {
@@ -51,7 +50,7 @@ class BaseEventMetric {
* This locks the internal state of the event metric to ensure safety across
* multiple threads preventing the caller from worrying about locking.
*/
Lock internal_lock_;
std::mutex internal_lock_;
};
// The EventMetric class is used to capture statistics about an event such as

83
metrics/include/metrics_collections.h
View File

@@ -8,6 +8,7 @@
#include <stddef.h>
#include <stdint.h>
#include <mutex>
#include <ostream>
#include "OEMCryptoCENC.h"
@@ -66,6 +67,8 @@ const int kErrorCodeFieldNumber =
::drm_metrics::Attributes::kErrorCodeFieldNumber;
const int kErrorCodeBoolFieldNumber =
::drm_metrics::Attributes::kErrorCodeBoolFieldNumber;
const int kErrorDetailFieldNumber =
::drm_metrics::Attributes::kErrorDetailFieldNumber;
const int kCdmSecurityLevelFieldNumber =
::drm_metrics::Attributes::kCdmSecurityLevelFieldNumber;
const int kSecurityLevelFieldNumber =
@@ -84,9 +87,15 @@ const int kEventTypeFieldNumber =
::drm_metrics::Attributes::kEventTypeFieldNumber;
const int kKeyRequestTypeFieldNumber =
::drm_metrics::Attributes::kKeyRequestTypeFieldNumber;
const int kLicenseTypeFieldNumber =
::drm_metrics::Attributes::kLicenseTypeFieldNumber;
} // anonymous namespace
// The maximum number of completed sessions that can be stored. More than this
// will cause some metrics to be discarded.
const int kMaxCompletedSessions = 40;
// This enum defines the conditions encountered during OEMCrypto Initialization
// in oemcrypto_adapter_dynamic.
typedef enum OEMCryptoInitializationMode {
@@ -106,10 +115,13 @@ typedef enum OEMCryptoInitializationMode {
OEMCrypto_INITIALIZED_USING_L1_INSTALLED_KEYBOX = 13,
OEMCrypto_INITIALIZED_USING_L3_INVALID_L1 = 14,
OEMCrypto_INITIALIZED_USING_L1_WITH_PROVISIONING_3_0 = 15,
OEMCrypto_INITIALIZED_L3_INITIALIZATION_FAILED = 16
OEMCrypto_INITIALIZED_L3_INITIALIZATION_FAILED = 16,
OEMCrypto_INITIALIZED_L3_RNG_FAILED = 17,
OEMCrypto_INITIALIZED_L3_SAVE_DEVICE_KEYS_FAILED = 18,
OEMCrypto_INITIALIZED_L3_READ_DEVICE_KEYS_FAILED = 19,
OEMCrypto_INITIALIZED_L3_VERIFY_DEVICE_KEYS_FAILED = 20,
} OEMCryptoInitializationMode;
// This class contains metrics for Crypto Session and OEM Crypto.
class CryptoMetrics {
public:
@@ -135,11 +147,12 @@ class CryptoMetrics {
EventMetric<kErrorCodeFieldNumber, CdmResponseType, kLengthFieldNumber,
Pow2Bucket, kSigningAlgorithmFieldNumber, CdmSigningAlgorithm>
crypto_session_generic_verify_;
CounterMetric<kErrorCodeBoolFieldNumber, bool>
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
crypto_session_get_device_unique_id_;
CounterMetric<kErrorCodeBoolFieldNumber, bool> crypto_session_get_token_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
crypto_session_get_token_;
ValueMetric<double> crypto_session_life_span_;
EventMetric<kErrorCodeBoolFieldNumber, bool>
EventMetric<kErrorCodeFieldNumber, CdmResponseType>
crypto_session_load_certificate_private_key_;
// This uses the requested security level.
EventMetric<kErrorCodeFieldNumber, CdmResponseType, kSecurityLevelFieldNumber,
@@ -265,13 +278,16 @@ class SessionMetrics {
// Metrics collected at the session level.
ValueMetric<double> cdm_session_life_span_; // Milliseconds.
EventMetric<kErrorCodeFieldNumber, CdmResponseType> cdm_session_renew_key_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
CounterMetric<kErrorCodeFieldNumber, CdmResponseType,
kErrorDetailFieldNumber, int32_t>
cdm_session_restore_offline_session_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
CounterMetric<kErrorCodeFieldNumber, CdmResponseType,
kErrorDetailFieldNumber, int32_t>
cdm_session_restore_usage_session_;
EventMetric<kKeyRequestTypeFieldNumber, CdmKeyRequestType>
cdm_session_license_request_latency_ms_;
ValueMetric<std::string> oemcrypto_build_info_;
// Serialize the session metrics to the provided |metric_group|.
// |metric_group| is owned by the caller and must not be null.
@@ -301,6 +317,8 @@ class OemCryptoDynamicAdapterMetrics {
// Set methods for OEMCrypto metrics.
void SetInitializationMode(OEMCryptoInitializationMode mode);
void SetLevel3InitializationError(OEMCryptoInitializationMode mode);
void SetPreviousInitializationFailure(OEMCryptoInitializationMode mode);
void SetL1ApiVersion(uint32_t version);
void SetL1MinApiVersion(uint32_t version);
@@ -313,8 +331,12 @@ class OemCryptoDynamicAdapterMetrics {
void Clear();
private:
mutable Lock adapter_lock_;
mutable std::mutex adapter_lock_;
ValueMetric<OEMCryptoInitializationMode>
level3_oemcrypto_initialization_error_;
ValueMetric<OEMCryptoInitializationMode> oemcrypto_initialization_mode_;
ValueMetric<OEMCryptoInitializationMode>
previous_oemcrypto_initialization_failure_;
ValueMetric<uint32_t> oemcrypto_l1_api_version_;
ValueMetric<uint32_t> oemcrypto_l1_min_api_version_;
};
@@ -335,36 +357,38 @@ class EngineMetrics {
~EngineMetrics();
// Add a new SessionMetrics instance and return a pointer to the caller.
// The new SessionMetrics instance is owned by this EngineMetrics instance
// and will exist until RemoveSession is called or this object is deleted.
SessionMetrics *AddSession();
// A shared_ptr is used since it's possible that the SessionMetrics instance
// may be in use after the EngineMetrics instance is closed. The EngineMetrics
// instance will hold a shared_ptr reference to the SessionMetrics instance
// until RemoveSession is called, the EngineMetrics instance is deleted, or
// the SessionMetrics instance is marked as completed and ConsolidateSessions
// removes it.
std::shared_ptr<SessionMetrics> AddSession();
// Removes the metrics object for the given session id. This should only
// be called when the SessionMetrics instance is no longer in use.
void RemoveSession(CdmSessionId session_id);
// Looks for session metrics that have been marked as completed. These metrics
// may be merged or discarded if there are too many completed session metric
// instances.
void ConsolidateSessions();
// Returns a pointer to the crypto metrics belonging to the engine instance.
// The CryptoMetrics instance is still owned by this object and will exist
// until this object is deleted.
CryptoMetrics *GetCryptoMetrics() { return &crypto_metrics_; }
// Serialize engine and session metrics into a serialized MetricsGroup
// instance and output that instance to the provided |metric_group|.
// |metric_group| is owned by the caller and must NOT be null.
// |completed_only| indicates that this call should only publish
// SessionMetrics instances that are marked as completed.
// |clear_sessions| indicates that this call should clear sessions metrics
// for those sessions that were serialized. This allows atomic
// serialization and closing of session-level metrics.
// void Serialize(drm_metrics::MetricsGroup* metric_group, bool
// completed_only,
// bool clear_serialized_sessions);
// Serialize engine and session metrics into a serialized WvCdmMetrics
// instance and output that instance to the provided |engine_metrics|.
// |engine_metrics| is owned by the caller and must NOT be null.
void Serialize(drm_metrics::WvCdmMetrics *engine_metrics) const;
void SetAppPackageName(const std::string &app_package_name);
// Metrics recorded at the engine level.
EventMetric<kErrorCodeFieldNumber, CdmResponseType> cdm_engine_add_key_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType,
kLicenseTypeFieldNumber, CdmLicenseType> cdm_engine_add_key_;
ValueMetric<std::string> cdm_engine_cdm_version_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
cdm_engine_close_session_;
@@ -374,13 +398,15 @@ class EngineMetrics {
cdm_engine_decrypt_;
CounterMetric<kErrorCodeBoolFieldNumber, bool>
cdm_engine_find_session_for_key_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType>
EventMetric<kErrorCodeFieldNumber, CdmResponseType,
kLicenseTypeFieldNumber, CdmLicenseType>
cdm_engine_generate_key_request_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType>
cdm_engine_get_provisioning_request_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
cdm_engine_get_secure_stop_ids_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType>
EventMetric<kErrorCodeFieldNumber, CdmResponseType,
kErrorDetailFieldNumber, int32_t>
cdm_engine_get_usage_info_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType>
cdm_engine_handle_provisioning_response_;
@@ -405,8 +431,11 @@ class EngineMetrics {
cdm_engine_unprovision_;
private:
mutable Lock session_metrics_lock_;
std::vector<metrics::SessionMetrics *> session_metrics_list_;
mutable std::mutex session_metrics_lock_;
std::vector<std::shared_ptr<metrics::SessionMetrics>>
active_session_metrics_list_;
std::vector<std::shared_ptr<metrics::SessionMetrics>>
completed_session_metrics_list_;
// This is used to populate the engine lifespan metric
metrics::TimerMetric life_span_internal_;
CryptoMetrics crypto_metrics_;

12
metrics/include/timer_metric.h
View File

@@ -1,19 +1,20 @@
#ifndef WVCDM_METRICS_TIMER_METRIC_H_
#define WVCDM_METRICS_TIMER_METRIC_H_
#include <stdint.h>
#include <chrono>
namespace wvcdm {
namespace metrics {
class TimerMetric {
public:
// Constructs a new TimerMetric.
explicit TimerMetric() : is_started_(false) {}
// Starts the clock running. If the clock was previously set, this resets it.
// IsStarted will return true after this call.
void Start();
// Returns whether or not the timer has started.
bool IsStarted() const { return is_started_; };
bool IsStarted() const { return is_started_; }
// Stops the clock and clears the current value. IsStarted will return false
// after this call.
void Clear();
@@ -23,10 +24,9 @@ class TimerMetric {
double AsUs() const;
private:
double sec_;
double usec_;
std::chrono::steady_clock clock_;
std::chrono::time_point<std::chrono::steady_clock> start_;
bool is_started_;
};
} // namespace metrics

35
metrics/include/value_metric.h
View File

@@ -6,6 +6,7 @@
#define WVCDM_METRICS_VALUE_METRIC_H_
#include <stdint.h>
#include <mutex>
#include <string>
#include "metrics.pb.h"
@@ -46,6 +47,7 @@ class ValueMetric {
// Record the value of the metric.
void Record(const T &value) {
std::unique_lock<std::mutex> lock(internal_lock_);
value_ = value;
has_value_ = true;
has_error_ = false;
@@ -53,19 +55,33 @@ class ValueMetric {
// Set the error code if an error was encountered.
void SetError(int error_code) {
std::unique_lock<std::mutex> lock(internal_lock_);
error_code_ = error_code;
has_value_ = false;
has_error_ = true;
}
bool HasValue() const { return has_value_; }
const T &GetValue() const { return value_; }
bool HasValue() const {
std::unique_lock<std::mutex> lock(internal_lock_);
return has_value_;
}
const T &GetValue() const {
std::unique_lock<std::mutex> lock(internal_lock_);
return value_;
}
bool HasError() const { return has_error_; }
int GetError() const { return error_code_; }
bool HasError() const {
std::unique_lock<std::mutex> lock(internal_lock_);
return has_error_;
}
int GetError() const {
std::unique_lock<std::mutex> lock(internal_lock_);
return error_code_;
}
// Clears the indicators that the metric or error was set.
void Clear() {
std::unique_lock<std::mutex> lock(internal_lock_);
has_value_ = false;
has_error_ = false;
}
@@ -73,6 +89,7 @@ class ValueMetric {
// Returns a new ValueMetric proto containing the metric value or the
// error code. If neither the error or value are set, it returns nullptr.
drm_metrics::ValueMetric *ToProto() const {
std::unique_lock<std::mutex> lock(internal_lock_);
if (has_error_) {
drm_metrics::ValueMetric *value_proto = new drm_metrics::ValueMetric;
value_proto->set_error_code(error_code_);
@@ -91,6 +108,16 @@ class ValueMetric {
int error_code_;
bool has_error_;
bool has_value_;
/*
* This locks the internal state of the value metric to ensure safety
* across multiple threads preventing the caller from worrying about
* locking.
*
* This field must be declared mutable because the lock must be takeable even
* in const methods.
*/
mutable std::mutex internal_lock_;
};
} // namespace metrics

16
metrics/src/attribute_handler.cpp
View File

@@ -80,6 +80,22 @@ void SetAttributeField<drm_metrics::Attributes::kKeyRequestTypeFieldNumber,
attributes->set_key_request_type(key_request_type);
}
template <>
void SetAttributeField<drm_metrics::Attributes::kLicenseTypeFieldNumber,
CdmLicenseType>(
const CdmLicenseType &license_type,
drm_metrics::Attributes *attributes) {
attributes->set_license_type(license_type);
}
template <>
void SetAttributeField<drm_metrics::Attributes::kErrorDetailFieldNumber,
int32_t>(
const int32_t &error_detail,
drm_metrics::Attributes *attributes) {
attributes->set_error_detail(error_detail);
}
template <>
void SetAttributeField<0, util::Unused>(const util::Unused &,
drm_metrics::Attributes *) {

2
metrics/src/counter_metric.cpp
View File

@@ -12,7 +12,7 @@ namespace metrics {
void BaseCounterMetric::Increment(const std::string &counter_key,
int64_t value) {
AutoLock lock(internal_lock_);
std::unique_lock<std::mutex> lock(internal_lock_);
if (value_map_.find(counter_key) == value_map_.end()) {
value_map_[counter_key] = value;

4
metrics/src/event_metric.cpp
View File

@@ -10,7 +10,7 @@ namespace wvcdm {
namespace metrics {
BaseEventMetric::~BaseEventMetric() {
AutoLock lock(internal_lock_);
std::unique_lock<std::mutex> lock(internal_lock_);
for (std::map<std::string, Distribution *>::iterator it = value_map_.begin();
it != value_map_.end(); it++) {
@@ -19,7 +19,7 @@ BaseEventMetric::~BaseEventMetric() {
}
void BaseEventMetric::Record(const std::string &key, double value) {
AutoLock lock(internal_lock_);
std::unique_lock<std::mutex> lock(internal_lock_);
Distribution *distribution;

12
metrics/src/metrics.proto
View File

@@ -46,6 +46,10 @@ message Attributes {
optional uint32 event_type = 15;
// Contains the CdmKeyRequestType defined in wv_cdm_types.h.
optional uint32 key_request_type = 16;
// Contains the CdmLicenseType defined in wv_cdm_types.h.
optional uint32 license_type = 17;
// Error detail supplemental to the error_code field.
optional int32 error_detail = 18;
}
// The Counter message is used to store a count value with an associated
@@ -155,7 +159,7 @@ message WvCdmMetrics {
// This contains metrics that were captured within a CdmSession. This contains
// nested CryptoMetrics that were captured in the context of the session.
// next id: 8
// next id: 9
message SessionMetrics {
optional ValueMetric session_id = 1;
optional CryptoMetrics crypto_metrics = 2;
@@ -164,11 +168,12 @@ message WvCdmMetrics {
repeated CounterMetric cdm_session_restore_offline_session = 5;
repeated CounterMetric cdm_session_restore_usage_session = 6;
repeated DistributionMetric cdm_session_license_request_latency_ms = 7;
optional ValueMetric oemcrypto_build_info = 8;
}
// These are metrics recorded at the Engine level. This includes CryptoSession
// metrics that were captured in the context of the engine.
// next id: 29
// next id: 31
message EngineMetrics {
optional CryptoMetrics crypto_metrics = 1;
@@ -200,6 +205,9 @@ message WvCdmMetrics {
repeated CounterMetric cdm_engine_remove_usage_info = 26;
repeated DistributionMetric cdm_engine_restore_key_time_us = 27;
repeated CounterMetric cdm_engine_unprovision = 28;
// OEMCrypto Initialize Metrics.
optional ValueMetric level3_oemcrypto_initialization_error = 29;
optional ValueMetric previous_oemcrypto_initialization_failure = 30;
}
optional EngineMetrics engine_metrics = 1;

117
metrics/src/metrics_collections.cpp
View File

@@ -13,13 +13,15 @@ using ::google::protobuf::RepeatedPtrField;
using ::wvcdm::metrics::EventMetric;
namespace {
// Helper struct for comparing session ids.
struct CompareSessionIds {
const std::string &target_;
CompareSessionIds(const wvcdm::CdmSessionId &target) : target_(target){};
bool operator()(const wvcdm::metrics::SessionMetrics *metrics) const {
bool operator()(const std::shared_ptr<wvcdm::metrics::SessionMetrics> metrics)
const {
return metrics->GetSessionId() == target_;
}
};
@@ -152,7 +154,7 @@ void CryptoMetrics::Serialize(WvCdmMetrics::CryptoMetrics *crypto_metrics)
crypto_metrics->mutable_oemcrypto_update_usage_entry());
}
SessionMetrics::SessionMetrics() {}
SessionMetrics::SessionMetrics() : session_id_(""), completed_(false) {}
void SessionMetrics::Serialize(WvCdmMetrics::SessionMetrics *session_metrics)
const {
@@ -177,35 +179,55 @@ void SessionMetrics::SerializeSessionMetrics(
session_metrics->mutable_cdm_session_restore_usage_session());
cdm_session_license_request_latency_ms_.ToProto(
session_metrics->mutable_cdm_session_license_request_latency_ms());
session_metrics->set_allocated_oemcrypto_build_info(
oemcrypto_build_info_.ToProto());
}
OemCryptoDynamicAdapterMetrics::OemCryptoDynamicAdapterMetrics()
: oemcrypto_initialization_mode_(),
: level3_oemcrypto_initialization_error_(),
oemcrypto_initialization_mode_(),
previous_oemcrypto_initialization_failure_(),
oemcrypto_l1_api_version_(),
oemcrypto_l1_min_api_version_() {}
void OemCryptoDynamicAdapterMetrics::SetInitializationMode(
OEMCryptoInitializationMode mode) {
AutoLock lock(adapter_lock_);
std::unique_lock<std::mutex> lock(adapter_lock_);
oemcrypto_initialization_mode_.Record(mode);
}
void OemCryptoDynamicAdapterMetrics::SetLevel3InitializationError(
OEMCryptoInitializationMode mode) {
std::unique_lock<std::mutex> lock(adapter_lock_);
level3_oemcrypto_initialization_error_.Record(mode);
}
void OemCryptoDynamicAdapterMetrics::SetPreviousInitializationFailure(
OEMCryptoInitializationMode mode) {
std::unique_lock<std::mutex> lock(adapter_lock_);
previous_oemcrypto_initialization_failure_.Record(mode);
}
void OemCryptoDynamicAdapterMetrics::SetL1ApiVersion(uint32_t version) {
AutoLock lock(adapter_lock_);
std::unique_lock<std::mutex> lock(adapter_lock_);
oemcrypto_l1_api_version_.Record(version);
}
void OemCryptoDynamicAdapterMetrics::SetL1MinApiVersion(uint32_t version) {
AutoLock lock(adapter_lock_);
std::unique_lock<std::mutex> lock(adapter_lock_);
oemcrypto_l1_min_api_version_.Record(version);
}
void OemCryptoDynamicAdapterMetrics::Serialize(
WvCdmMetrics::EngineMetrics *engine_metrics) const {
AutoLock lock(adapter_lock_);
std::unique_lock<std::mutex> lock(adapter_lock_);
engine_metrics->set_allocated_level3_oemcrypto_initialization_error(
oemcrypto_initialization_mode_.ToProto());
engine_metrics->set_allocated_oemcrypto_initialization_mode(
oemcrypto_initialization_mode_.ToProto());
engine_metrics->set_allocated_previous_oemcrypto_initialization_failure(
oemcrypto_initialization_mode_.ToProto());
engine_metrics->set_allocated_oemcrypto_l1_api_version(
oemcrypto_l1_api_version_.ToProto());
engine_metrics->set_allocated_oemcrypto_l1_min_api_version(
@@ -213,9 +235,11 @@ void OemCryptoDynamicAdapterMetrics::Serialize(
}
void OemCryptoDynamicAdapterMetrics::Clear() {
AutoLock lock(adapter_lock_);
std::unique_lock<std::mutex> lock(adapter_lock_);
level3_oemcrypto_initialization_error_.Clear();
oemcrypto_initialization_mode_.Clear();
previous_oemcrypto_initialization_failure_.Clear();
oemcrypto_l1_api_version_.Clear();
oemcrypto_l1_min_api_version_.Clear();
}
@@ -235,36 +259,65 @@ EngineMetrics::EngineMetrics() {
}
EngineMetrics::~EngineMetrics() {
AutoLock lock(session_metrics_lock_);
std::vector<SessionMetrics *>::iterator i;
if (!session_metrics_list_.empty()) {
LOGV("EngineMetrics::~EngineMetrics. Session count: %d",
session_metrics_list_.size());
std::unique_lock<std::mutex> lock(session_metrics_lock_);
if (!active_session_metrics_list_.empty()
|| !completed_session_metrics_list_.empty()) {
LOGV("EngineMetrics::~EngineMetrics. Session counts: "
"active %d. completed %d.", active_session_metrics_list_.size(),
completed_session_metrics_list_.size());
}
for (i = session_metrics_list_.begin(); i != session_metrics_list_.end();
i++) {
delete *i;
}
session_metrics_list_.clear();
}
SessionMetrics *EngineMetrics::AddSession() {
AutoLock lock(session_metrics_lock_);
SessionMetrics *metrics = new SessionMetrics();
session_metrics_list_.push_back(metrics);
return metrics;
std::shared_ptr<SessionMetrics> EngineMetrics::AddSession() {
std::unique_lock<std::mutex> lock(session_metrics_lock_);
active_session_metrics_list_.push_back(std::make_shared<SessionMetrics>());
return active_session_metrics_list_.back();
}
void EngineMetrics::RemoveSession(wvcdm::CdmSessionId session_id) {
AutoLock lock(session_metrics_lock_);
session_metrics_list_.erase(
std::remove_if(session_metrics_list_.begin(), session_metrics_list_.end(),
std::unique_lock<std::mutex> lock(session_metrics_lock_);
active_session_metrics_list_.erase(
std::remove_if(active_session_metrics_list_.begin(),
active_session_metrics_list_.end(),
CompareSessionIds(session_id)),
session_metrics_list_.end());
active_session_metrics_list_.end());
completed_session_metrics_list_.erase(
std::remove_if(completed_session_metrics_list_.begin(),
completed_session_metrics_list_.end(),
CompareSessionIds(session_id)),
completed_session_metrics_list_.end());
}
void EngineMetrics::ConsolidateSessions() {
auto completed_filter =
[] (const std::shared_ptr<SessionMetrics>& session_metrics) {
return session_metrics->IsCompleted();
};
std::unique_lock<std::mutex> lock(session_metrics_lock_);
std::copy_if(active_session_metrics_list_.begin(),
active_session_metrics_list_.end(),
std::back_inserter(completed_session_metrics_list_),
completed_filter);
active_session_metrics_list_.erase(
std::remove_if(active_session_metrics_list_.begin(),
active_session_metrics_list_.end(),
completed_filter),
active_session_metrics_list_.end());
// TODO(b/118664842): Add support to merge older metrics into one
// consolidated metric.
int excess_completed = completed_session_metrics_list_.size()
- kMaxCompletedSessions;
if (excess_completed > 0) {
completed_session_metrics_list_.erase(
completed_session_metrics_list_.begin(),
completed_session_metrics_list_.begin() + excess_completed);
}
}
void EngineMetrics::Serialize(WvCdmMetrics *wv_metrics) const {
AutoLock lock(session_metrics_lock_);
std::unique_lock<std::mutex> lock(session_metrics_lock_);
WvCdmMetrics::EngineMetrics *engine_metrics =
wv_metrics->mutable_engine_metrics();
// Serialize the most recent metrics from the OemCyrpto dynamic adapter.
@@ -277,8 +330,12 @@ void EngineMetrics::Serialize(WvCdmMetrics *wv_metrics) const {
}
SerializeEngineMetrics(engine_metrics);
for (std::vector<metrics::SessionMetrics *>::const_iterator it =
session_metrics_list_.begin(); it != session_metrics_list_.end(); it++) {
for (auto it = completed_session_metrics_list_.begin();
it != completed_session_metrics_list_.end(); it++) {
(*it)->Serialize(wv_metrics->add_session_metrics());
}
for (auto it = active_session_metrics_list_.begin();
it != active_session_metrics_list_.end(); it++) {
(*it)->Serialize(wv_metrics->add_session_metrics());
}
}

22
metrics/src/timer_metric.cpp
View File

@@ -1,39 +1,23 @@
#include "timer_metric.h"
#include <stddef.h>
#include <sys/time.h>
namespace wvcdm {
namespace metrics {
void TimerMetric::Start() {
struct timeval tv;
gettimeofday(&tv, NULL);
sec_ = tv.tv_sec;
usec_ = tv.tv_usec;
start_ = clock_.now();
is_started_ = true;
}
void TimerMetric::Clear() {
is_started_ = false;
sec_ = 0;
usec_ = 0;
}
double TimerMetric::AsMs() const {
struct timeval tv;
gettimeofday(&tv, NULL);
return usec_ > tv.tv_usec ?
(tv.tv_sec - sec_ - 1) * 1000.0 + (tv.tv_usec - usec_ + 1000000.0) / 1000.0 :
(tv.tv_sec - sec_) * 1000.0 + (tv.tv_usec - usec_) / 1000.0;
return (clock_.now() - start_) / std::chrono::milliseconds(1);
}
double TimerMetric::AsUs() const {
struct timeval tv;
gettimeofday(&tv, NULL);
return usec_ > tv.tv_usec ?
(tv.tv_sec - sec_ - 1) * 1000000.0 + (tv.tv_usec - usec_ + 1000000.0) :
(tv.tv_sec - sec_) * 1000000.0 + (tv.tv_usec - usec_);
return (clock_.now() - start_) / std::chrono::microseconds(1);
}
} // namespace metrics

6
metrics/src/value_metric.cpp
View File

@@ -53,6 +53,12 @@ void SetValue<unsigned long>(drm_metrics::ValueMetric *value_proto,
value_proto->set_int_value((int64_t)value);
}
template <>
void SetValue<unsigned long long>(drm_metrics::ValueMetric *value_proto,
const unsigned long long &value) {
value_proto->set_int_value((int64_t)value);
}
template <>
void SetValue<bool>(drm_metrics::ValueMetric *value_proto,
const bool &value) {

1
metrics/test/counter_metric_unittest.cpp
View File

@@ -6,7 +6,6 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
using drm_metrics::TestMetrics;

1
metrics/test/event_metric_unittest.cpp
View File

@@ -6,7 +6,6 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
using drm_metrics::TestMetrics;

472
metrics/test/metrics_collections_unittest.cpp
View File

@@ -7,6 +7,7 @@
#include <sstream>
#include "device_files.h"
#include "gmock/gmock.h"
#include "google/protobuf/text_format.h"
#include "gtest/gtest.h"
@@ -14,9 +15,14 @@
#include "metrics.pb.h"
#include "wv_cdm_types.h"
using drm_metrics::MetricsGroup;
using drm_metrics::WvCdmMetrics;
using google::protobuf::TextFormat;
namespace {
const char kSessionId1[] = "session_id_1";
const char kSessionId2[] = "session_id_2";
} // anonymous namespace
namespace wvcdm {
namespace metrics {
@@ -29,216 +35,213 @@ 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);
engine_metrics.cdm_engine_close_session_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_decrypt_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_find_session_for_key_.Record(1.0, false);
engine_metrics.cdm_engine_generate_key_request_.Record(1.0, NO_ERROR);
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_get_provisioning_request_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_get_usage_info_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_get_usage_info_.Record(1.0, NO_ERROR,
UNKNOWN_ERROR);
engine_metrics.cdm_engine_handle_provisioning_response_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_life_span_.Record(1.0);
engine_metrics.cdm_engine_open_key_set_session_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_open_session_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_open_key_set_session_.Increment(NO_ERROR);
engine_metrics.cdm_engine_open_session_.Increment(NO_ERROR);
engine_metrics.cdm_engine_query_key_status_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_release_all_usage_info_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_release_usage_info_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_remove_keys_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_release_all_usage_info_.Increment(NO_ERROR);
engine_metrics.cdm_engine_release_usage_info_.Increment(NO_ERROR);
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_.Record(1.0, NO_ERROR, kSecurityLevelL1);
engine_metrics.cdm_engine_unprovision_.Increment(NO_ERROR, kSecurityLevelL1);
drm_metrics::MetricsGroup actual_metrics;
engine_metrics.Serialize(&actual_metrics, true, false);
// Also set and serialize the oemcrypto dynamic adapter metrics.
OemCryptoDynamicAdapterMetrics adapter_metrics;
adapter_metrics.SetInitializationMode(OEMCrypto_INITIALIZED_FORCING_L3);
adapter_metrics.SetL1ApiVersion(2);
adapter_metrics.SetL1MinApiVersion(1);
// For each EventMetric, 2 metrics get serialized since only one sample was
// taken. So, the total number of serialized metrics are 2*17.
ASSERT_EQ(2 * 17, actual_metrics.metric_size());
EXPECT_EQ(0, actual_metrics.metric_sub_group_size());
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
adapter_metrics.Serialize(actual_metrics.mutable_engine_metrics());
ASSERT_TRUE(actual_metrics.has_engine_metrics());
EXPECT_EQ(0, actual_metrics.session_metrics_size());
// Spot check some metrics.
EXPECT_EQ("/drm/widevine/cdm_engine/add_key/time/count{error:2}",
actual_metrics.metric(0).name());
EXPECT_EQ("/drm/widevine/cdm_engine/close_session/count{error:0}",
actual_metrics.metric(3).name());
EXPECT_EQ("/drm/widevine/cdm_engine/decrypt/time/mean{error:0}",
actual_metrics.metric(5).name());
EXPECT_EQ(1.0, actual_metrics.metric(5).value().double_value());
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());
}
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);
engine_metrics.cdm_engine_close_session_.Record(1.0, NO_ERROR);
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();
crypto_metrics->crypto_session_get_device_unique_id_.Increment(NO_ERROR);
crypto_metrics->crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
crypto_metrics->crypto_session_get_device_unique_id_
.Record(4.0, false);
drm_metrics::MetricsGroup actual_metrics;
engine_metrics.Serialize(&actual_metrics, true, false);
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
// For each EventMetric, 2 metrics get serialized since only one sample was
// taken. So, the total number of serialized metrics are 2*4 since we
// touched 4 metrics.
ASSERT_EQ(2 * 4, actual_metrics.metric_size());
EXPECT_EQ(0, actual_metrics.metric_sub_group_size());
ASSERT_TRUE(actual_metrics.has_engine_metrics());
EXPECT_EQ(0, actual_metrics.session_metrics_size());
// Spot check some metrics.
EXPECT_EQ("/drm/widevine/cdm_engine/add_key/time/count{error:2}",
actual_metrics.metric(0).name());
EXPECT_EQ(
"/drm/widevine/crypto_session/generic_decrypt/time/count"
"{error:0&length:1024&encryption_algorithm:1}",
actual_metrics.metric(4).name());
EXPECT_EQ(
"/drm/widevine/crypto_session/get_device_unique_id/count{success:0}",
actual_metrics.metric(7).name());
EXPECT_EQ(4.0, actual_metrics.metric(7).value().double_value());
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(UNKNOWN_ERROR, actual_metrics.engine_metrics()
.cdm_engine_close_session(0)
.attributes().error_code());
ASSERT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_get_device_unique_id_size());
EXPECT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_get_device_unique_id(0)
.count());
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_get_device_unique_id(0)
.attributes().error_code());
ASSERT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_generic_decrypt_time_us_size());
EXPECT_EQ(2.0, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_generic_decrypt_time_us(0)
.mean());
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_generic_decrypt_time_us(0)
.attributes().error_code());
}
TEST_F(EngineMetricsTest, EmptyEngineMetrics) {
EngineMetrics engine_metrics;
drm_metrics::MetricsGroup actual_metrics;
engine_metrics.Serialize(&actual_metrics, true, false);
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
EXPECT_EQ(0, actual_metrics.metric_size());
EXPECT_EQ(0, actual_metrics.metric_sub_group_size());
// Empty engine metics will still produce an engine metrics record.
EXPECT_TRUE(actual_metrics.has_engine_metrics());
EXPECT_EQ(0, actual_metrics.session_metrics_size());
}
TEST_F(EngineMetricsTest, EngineMetricsWithCompletedSessions) {
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);
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease);
engine_metrics.GetCryptoMetrics()
->crypto_session_load_certificate_private_key_.Record(2.0, true);
->crypto_session_load_certificate_private_key_.Record(2.0, NO_ERROR);
// Create two sessions and record some metrics.
SessionMetrics* session_metrics_1 = engine_metrics.AddSession();
session_metrics_1->SetSessionId("session_id_1");
SessionMetrics* session_metrics_2 = engine_metrics.AddSession();
session_metrics_2->SetSessionId("session_id_2");
std::shared_ptr<SessionMetrics> session_metrics_1 =
engine_metrics.AddSession();
session_metrics_1->SetSessionId(kSessionId1);
std::shared_ptr<SessionMetrics> session_metrics_2 =
engine_metrics.AddSession();
session_metrics_2->SetSessionId(kSessionId2);
// Record a CryptoMetrics metric in the session.
session_metrics_2->GetCryptoMetrics()->crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
session_metrics_2->SetSessionId("session_id_2");
// Mark only session 2 as completed.
session_metrics_2->SetCompleted();
drm_metrics::MetricsGroup actual_metrics;
engine_metrics.Serialize(&actual_metrics, true, false);
// Validate metric counts.
// For each EventMetric, 2 metrics get serialized since only one sample was
// taken. So, the total number of serialized metrics are 2*2 since we
// touched 2 metrics.
ASSERT_EQ(2 * 2, actual_metrics.metric_size());
ASSERT_EQ(1, actual_metrics.metric_sub_group_size());
ASSERT_EQ(3, actual_metrics.metric_sub_group(0).metric_size());
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
// Spot check some metrics.
EXPECT_EQ("/drm/widevine/cdm_engine/add_key/time/count{error:2}",
actual_metrics.metric(0).name());
EXPECT_EQ("/drm/widevine/crypto_session/load_certificate_private_key"
"/time/count{success:1}",
actual_metrics.metric(2).name());
EXPECT_EQ("/drm/widevine/cdm_session/session_id",
actual_metrics.metric_sub_group(0).metric(0).name());
EXPECT_EQ(
"session_id_2",
actual_metrics.metric_sub_group(0).metric(0).value().string_value());
EXPECT_EQ(
"/drm/widevine/crypto_session/generic_decrypt/time/count"
"{error:0&length:1024&encryption_algorithm:1}",
actual_metrics.metric_sub_group(0).metric(1).name());
ASSERT_TRUE(actual_metrics.has_engine_metrics());
EXPECT_EQ(1,
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
EXPECT_EQ(2, actual_metrics.session_metrics_size());
EXPECT_EQ(kSessionId1,
actual_metrics.session_metrics(0).session_id().string_value());
EXPECT_EQ(kSessionId2,
actual_metrics.session_metrics(1).session_id().string_value());
EXPECT_EQ(1, actual_metrics.session_metrics(1).crypto_metrics()
.crypto_session_generic_decrypt_time_us_size());
}
TEST_F(EngineMetricsTest, EngineMetricsSerializeAllSessions) {
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessions) {
EngineMetrics engine_metrics;
// Create two sessions and record some metrics.
SessionMetrics* session_metrics_1 = engine_metrics.AddSession();
session_metrics_1->SetSessionId("session_id_1");
SessionMetrics* session_metrics_2 = engine_metrics.AddSession();
session_metrics_2->SetSessionId("session_id_2");
// Mark only session 2 as completed.
session_metrics_2->SetCompleted();
// Create one more session than the max allowed closed sessions.
std::vector<std::shared_ptr<SessionMetrics>> session_metrics;
for (int i = 0; i < kMaxCompletedSessions + 1; i++) {
session_metrics.push_back(engine_metrics.AddSession());
session_metrics.back()->SetSessionId(std::to_string(i));
}
drm_metrics::MetricsGroup actual_metrics;
engine_metrics.Serialize(&actual_metrics, false, false);
// Mark sessions as completed.
for (auto it = session_metrics.begin(); it != session_metrics.end(); it++) {
(*it)->SetCompleted();
}
// Validate metric counts.
// No Engine-level metrics were recorded.
ASSERT_EQ(0, actual_metrics.metric_size());
// Two sub groups, 1 per session.
ASSERT_EQ(2, actual_metrics.metric_sub_group_size());
ASSERT_EQ(1, actual_metrics.metric_sub_group(0).metric_size());
engine_metrics.ConsolidateSessions();
// Spot check some metrics.
EXPECT_EQ("/drm/widevine/cdm_session/session_id",
actual_metrics.metric_sub_group(0).metric(0).name());
EXPECT_EQ(
"session_id_1",
actual_metrics.metric_sub_group(0).metric(0).value().string_value());
EXPECT_EQ("/drm/widevine/cdm_session/session_id",
actual_metrics.metric_sub_group(1).metric(0).name());
EXPECT_EQ(
"session_id_2",
actual_metrics.metric_sub_group(1).metric(0).value().string_value());
// Consolidate the metrics now. These should now be consolidated down to
// kMaxCompletedSessions.
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
ASSERT_EQ(kMaxCompletedSessions, actual_metrics.session_metrics_size());
}
TEST_F(EngineMetricsTest, EngineMetricsRemoveSessions) {
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoClosedSessions) {
EngineMetrics engine_metrics;
// Create two sessions and record some metrics.
SessionMetrics* session_metrics_1 = engine_metrics.AddSession();
session_metrics_1->SetSessionId("session_id_1");
SessionMetrics* session_metrics_2 = engine_metrics.AddSession();
session_metrics_2->SetSessionId("session_id_2");
// Mark only session 2 as completed.
session_metrics_2->SetCompleted();
// Create one more session than the max allowed closed sessions.
std::vector<std::shared_ptr<SessionMetrics>> session_metrics;
for (int i = 0; i < kMaxCompletedSessions + 1; i++) {
session_metrics.push_back(engine_metrics.AddSession());
session_metrics.back()->SetSessionId(std::to_string(i));
}
// Serialize all metrics, don't remove any.
drm_metrics::MetricsGroup actual_metrics;
engine_metrics.Serialize(&actual_metrics, false, false);
// Consolidate sessions will do nothing since no sessions are closed.
engine_metrics.ConsolidateSessions();
// Validate metric counts.
// Two sub groups, 1 per session.
ASSERT_EQ(2, actual_metrics.metric_sub_group_size());
// Serializing now will include all sessions since none are closed.
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
ASSERT_EQ(kMaxCompletedSessions + 1, actual_metrics.session_metrics_size());
}
// Serialize completed metrics, remove them.
actual_metrics.Clear();
engine_metrics.Serialize(&actual_metrics, true, true);
// Validate metric counts.
// Only one, completed session should exist.
ASSERT_EQ(1, actual_metrics.metric_sub_group_size());
ASSERT_EQ(1, actual_metrics.metric_sub_group(0).metric_size());
EXPECT_EQ(
"session_id_2",
actual_metrics.metric_sub_group(0).metric(0).value().string_value());
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoSessions) {
EngineMetrics engine_metrics;
// Serialize all metrics, remove them.
actual_metrics.Clear();
engine_metrics.Serialize(&actual_metrics, false, true);
// Validate metric counts.
// Only one, non-complete session should exist.
ASSERT_EQ(1, actual_metrics.metric_sub_group_size());
ASSERT_EQ(1, actual_metrics.metric_sub_group(0).metric_size());
EXPECT_EQ(
"session_id_1",
actual_metrics.metric_sub_group(0).metric(0).value().string_value());
// Consolidate sessions will do nothing since there are no sessions
engine_metrics.ConsolidateSessions();
// Serialize all metrics, don't remove any.
actual_metrics.Clear();
engine_metrics.Serialize(&actual_metrics, false, false);
// Validate metric counts.
// There should be no more metric subgroups left.
ASSERT_EQ(0, actual_metrics.metric_sub_group_size());
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
ASSERT_EQ(0, actual_metrics.session_metrics_size());
}
class SessionMetricsTest : public ::testing::Test {
@@ -246,48 +249,46 @@ class SessionMetricsTest : public ::testing::Test {
TEST_F(SessionMetricsTest, AllSessionMetrics) {
SessionMetrics session_metrics;
session_metrics.SetSessionId("session_id 1");
session_metrics.SetSessionId(kSessionId1);
session_metrics.cdm_session_life_span_.Record(1.0);
session_metrics.cdm_session_renew_key_.Record(1.0, NO_ERROR);
session_metrics.cdm_session_restore_offline_session_.Record(1.0, NO_ERROR);
session_metrics.cdm_session_restore_usage_session_.Record(1.0, NO_ERROR);
session_metrics.cdm_session_restore_offline_session_.Increment(
NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized);
session_metrics.cdm_session_restore_usage_session_.Increment(
NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized);
session_metrics.cdm_session_license_request_latency_ms_.Record(
2.0, kKeyRequestTypeInitial);
// Record a CryptoMetrics metric in the session.
session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
MetricsGroup actual_metrics;
WvCdmMetrics::SessionMetrics actual_metrics;
session_metrics.Serialize(&actual_metrics);
ASSERT_EQ(11, actual_metrics.metric_size());
EXPECT_EQ(0, actual_metrics.metric_sub_group_size());
// Spot check some metrics.
EXPECT_EQ("/drm/widevine/cdm_session/session_id",
actual_metrics.metric(0).name());
EXPECT_EQ("/drm/widevine/cdm_session/life_span",
actual_metrics.metric(1).name());
EXPECT_EQ("/drm/widevine/cdm_session/renew_key/time/mean{error:0}",
actual_metrics.metric(4).name());
EXPECT_EQ(1.0, actual_metrics.metric(4).value().double_value());
EXPECT_EQ("/drm/widevine/crypto_session/generic_decrypt/time/count"
"{error:0&length:1024&encryption_algorithm:1}",
actual_metrics.metric(9).name());
// 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());
}
TEST_F(SessionMetricsTest, EmptySessionMetrics) {
SessionMetrics session_metrics;
MetricsGroup actual_metrics;
WvCdmMetrics::SessionMetrics actual_metrics;
session_metrics.Serialize(&actual_metrics);
// Session metric always has a session id.
ASSERT_EQ(1, actual_metrics.metric_size());
EXPECT_EQ("/drm/widevine/cdm_session/session_id",
actual_metrics.metric(0).name());
EXPECT_EQ("", actual_metrics.metric(0).value().string_value());
EXPECT_EQ(0, actual_metrics.metric_sub_group_size());
EXPECT_TRUE(actual_metrics.has_crypto_metrics());
EXPECT_FALSE(actual_metrics.has_session_id());
EXPECT_FALSE(actual_metrics.has_cdm_session_life_span_ms());
EXPECT_EQ(0, actual_metrics.cdm_session_renew_key_time_us_size());
EXPECT_EQ(0, actual_metrics.cdm_session_restore_offline_session_size());
EXPECT_EQ(0, actual_metrics.cdm_session_restore_usage_session_size());
}
class CryptoMetricsTest : public ::testing::Test {
@@ -297,10 +298,9 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
CryptoMetrics crypto_metrics;
// Crypto session metrics.
crypto_metrics.crypto_session_delete_all_usage_reports_
.Record(1.0, NO_ERROR);
crypto_metrics.crypto_session_delete_all_usage_reports_.Increment(NO_ERROR);
crypto_metrics.crypto_session_delete_multiple_usage_information_
.Record(1.0, NO_ERROR);
.Increment(NO_ERROR);
crypto_metrics.crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
crypto_metrics.crypto_session_generic_encrypt_
@@ -309,42 +309,39 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
crypto_metrics.crypto_session_generic_verify_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
crypto_metrics.crypto_session_get_device_unique_id_.Record(1.0, true);
crypto_metrics.crypto_session_get_security_level_
.Record(1.0, kSecurityLevelL1);
crypto_metrics.crypto_session_get_system_id_.Record(1.0, true, 1234);
crypto_metrics.crypto_session_get_token_.Record(1.0, true);
crypto_metrics.crypto_session_get_device_unique_id_.Increment(NO_ERROR);
crypto_metrics.crypto_session_get_token_.Increment(NO_ERROR);
crypto_metrics.crypto_session_life_span_.Record(1.0);
crypto_metrics.crypto_session_load_certificate_private_key_
.Record(1.0, true);
.Record(1.0, NO_ERROR);
crypto_metrics.crypto_session_open_.Record(1.0, NO_ERROR, kLevelDefault);
crypto_metrics.crypto_session_update_usage_information_
.Record(1.0, NO_ERROR);
crypto_metrics.crypto_session_usage_information_support_.Record(1.0, true);
crypto_metrics.crypto_session_usage_information_support_.Record(true);
crypto_metrics.crypto_session_security_level_.Record(kSecurityLevelL2);
// Oem crypto metrics.
crypto_metrics.oemcrypto_api_version_.Record(1.0, 123, kLevelDefault);
crypto_metrics.oemcrypto_api_version_.Record(123);
crypto_metrics.oemcrypto_close_session_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_copy_buffer_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED,
kLevelDefault, Pow2Bucket(1025));
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_deactivate_usage_entry_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_decrypt_cenc_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_delete_usage_entry_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_delete_usage_table_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_derive_keys_from_session_key_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_force_delete_usage_entry_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_derived_keys_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_nonce_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_rsa_signature_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generate_signature_
@@ -358,87 +355,44 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
crypto_metrics.oemcrypto_generic_verify_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_get_device_id_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_get_hdcp_capability_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_get_key_data_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED,
Pow2Bucket(1025), kLevelDefault);
crypto_metrics.oemcrypto_get_max_number_of_sessions_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_get_number_of_open_sessions_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_get_oem_public_certificate_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_get_provisioning_method_
.Record(1.0, OEMCrypto_Keybox, kLevelDefault);
crypto_metrics.oemcrypto_get_random_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_max_number_of_sessions_.Record(7);
crypto_metrics.oemcrypto_number_of_open_sessions_.Record(5);
crypto_metrics.oemcrypto_get_oem_public_certificate_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_provisioning_method_.Record(OEMCrypto_Keybox);
crypto_metrics.oemcrypto_get_random_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_initialize_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_install_keybox_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_is_anti_rollback_hw_present_
.Record(1.0, true, kLevelDefault);
crypto_metrics.oemcrypto_is_keybox_valid_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_is_anti_rollback_hw_present_.Record(true);
crypto_metrics.oemcrypto_is_keybox_valid_.Record(true);
crypto_metrics.oemcrypto_load_device_rsa_key_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_keys_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_test_keybox_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_test_rsa_key_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_open_session_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_refresh_keys_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_report_usage_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_report_usage_.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_rewrap_device_rsa_key_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_rewrap_device_rsa_key_30_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_security_level_
.Record(1.0, kSecurityLevelL2, kLevelDefault);
crypto_metrics.oemcrypto_security_patch_level_
.Record(1.0, 123, kLevelDefault);
crypto_metrics.oemcrypto_security_patch_level_.Record(123);
crypto_metrics.oemcrypto_select_key_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_supports_usage_table_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_update_usage_table_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_wrap_keybox_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED);
// Internal OEMCrypto Metrics
crypto_metrics.oemcrypto_initialization_mode_
.Record(1.0, OEMCrypto_INITIALIZED_FORCING_L3);
crypto_metrics.oemcrypto_l1_api_version_.Record(1.0, 12, 123);
MetricsGroup actual_metrics;
WvCdmMetrics::CryptoMetrics actual_metrics;
crypto_metrics.Serialize(&actual_metrics);
// 61 EventMetric instances, 2 values each.
ASSERT_EQ(122, actual_metrics.metric_size());
// Spot check some metrics.
EXPECT_EQ(
"/drm/widevine/crypto_session/delete_all_usage_reports/count"
"{error:0}",
actual_metrics.metric(0).name());
EXPECT_EQ(1, actual_metrics.metric(0).value().int_value());
EXPECT_EQ(
"/drm/widevine/oemcrypto/l1_api_version/mean{version:12&min_version:123}",
actual_metrics.metric(121).name());
EXPECT_EQ(1.0, actual_metrics.metric(121).value().double_value());
// No subgroups should exist.
EXPECT_EQ(0, actual_metrics.metric_sub_group_size());
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());
}
} // namespace metrics

12
metrics/test/value_metric_unittest.cpp
View File

@@ -2,6 +2,7 @@
//
// Unit tests for ValueMetric.
#include <memory>
#include <string>
#include "value_metric.h"
@@ -9,7 +10,6 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "metrics.pb.h"
#include "scoped_ptr.h"
namespace wvcdm {
namespace metrics {
@@ -18,7 +18,7 @@ TEST(ValueMetricTest, StringValue) {
ValueMetric<std::string> metric;
metric.Record("foo");
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ("foo", metric_proto->string_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
@@ -27,7 +27,7 @@ TEST(ValueMetricTest, DoubleValue) {
ValueMetric<double> metric;
metric.Record(42.0);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42.0, metric_proto->double_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
@@ -36,7 +36,7 @@ TEST(ValueMetricTest, Int32Value) {
ValueMetric<int32_t> metric;
metric.Record(42);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42, metric_proto->int_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
@@ -45,7 +45,7 @@ TEST(ValueMetricTest, Int64Value) {
ValueMetric<int64_t> metric;
metric.Record(42);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42, metric_proto->int_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
@@ -55,7 +55,7 @@ TEST(ValueMetricTest, SetError) {
metric.Record(42);
metric.SetError(7);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(7, metric_proto->error_code());
ASSERT_FALSE(metric_proto->has_int_value());
}