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

Refactored metrics to support pull model.

Browse Source 
MetricsGroup split into 3 groups, session, engine, and crypto.
MetricsFrontEnd and Report removed.

This is a merge from wvgerrit/28420

Bug: 36217927
Test: Added unit tests to cover modified code.
Change-Id: I2f39f99ce88cc2229d6d1aa9459c67c5b86ccef4
This commit is contained in:
Adam Stone
2017-03-29 17:03:43 -07:00
parent 0a5fe1ffad
commit a34e279d0f
22 changed files with 478 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
libwvdrmengine/cdm/metrics/include/event_metric.h
View File

@@ -18,7 +18,7 @@
#include "lock.h"
#include "distribution.h"
#include "metric_publisher.h"
#include "metric_serialization.h"
namespace wvcdm {
namespace metrics {
@@ -27,11 +27,11 @@ class EventMetricTest;
// This base class provides the common defintion used by all templated
// instances of EventMetric.
class BaseEventMetric : public MetricPublisher {
class BaseEventMetric : public MetricSerializable {
public:
// Publish metric values to the MetricNotification. |subscriber| must
// Send metric values to the MetricSerializer. |serializer| must
// not be null and is owned by the caller.
virtual void Publish(MetricNotification* subscriber);
virtual void Serialize(MetricSerializer* serializer);
protected:
// Instantiates a BaseEventMetric.

46
libwvdrmengine/cdm/metrics/include/metric_publisher.h
View File

@@ -1,46 +0,0 @@
// Copyright 2017 Google Inc. All Rights Reserved.
//
// This file contains the declarations for the Metric class and related
// types.
#ifndef WVCDM_METRICS_METRIC_PUBLISHER_H_
#define WVCDM_METRICS_METRIC_PUBLISHER_H_
namespace wvcdm {
namespace metrics {
// The MetricNotification is implemented by the code that instantiates
// MetricPublisher instances. The caller provides this MetricNotification
// instance to MetricPublisher::Publish. In turn, Publish will make a call to
// UpdateMetric for each value to be published. The Metric may contain zero or
// more values to be updated.
class MetricNotification {
public:
virtual ~MetricNotification() {};
// The metric_id is the metric name, plus the metric part name, and the
// metric field name/value string. E.g.
// name: "drm/cdm/decrypt/duration"
// part: "mean"
// field name/value string: "{error_code:0&buffer_size:1024}"
// becomes: "drm/cdm/decrypt/duration/mean/{error_code:0&buffer_size:1024}".
virtual void UpdateString(const std::string& metric_id,
const std::string& value) = 0;
virtual void UpdateInt32(const std::string& metric_id, int32_t value) = 0;
virtual void UpdateInt64(const std::string& metric_id, int64_t value) = 0;
virtual void UpdateDouble(const std::string& metric_id, double value) = 0;
};
// This abstract class merely provides the definition for publishing the value
// of the metric.
class MetricPublisher {
public:
virtual ~MetricPublisher() { }
// Publish metric values to the MetricNotification. |subscriber| must
// not be null and is owned by the caller.
virtual void Publish(MetricNotification* subscriber) = 0;
};
} // namespace metrics
} // namespace wvcdm
#endif // WVCDM_METRICS_METRIC_PUBLISHER_H_

46
libwvdrmengine/cdm/metrics/include/metric_serialization.h Normal file
View File

@@ -0,0 +1,46 @@
// Copyright 2017 Google Inc. All Rights Reserved.
//
// This file contains the declarations for the Metric class and related
// types.
#ifndef WVCDM_METRICS_METRIC_SERIALIZATION_H_
#define WVCDM_METRICS_METRIC_SERIALIZATION_H_
namespace wvcdm {
namespace metrics {
// The MetricSerializer is implemented by the code that instantiates
// MetricSerializable instances. The caller provides this MetricSerializer
// instance to MetricSerializable::Serialize. In turn, Serialize will make a
// call to Set* for each value to be Serialized. The MetricSerialiable
// implementation may set zero or more values on the MetricSerializer.
class MetricSerializer {
public:
virtual ~MetricSerializer() {};
// The metric_id is the metric name, plus the metric part name, and the
// metric field name/value string. E.g.
// name: "drm/cdm/decrypt/duration"
// part: "mean"
// field name/value string: "{error_code:0&buffer_size:1024}"
// becomes: "drm/cdm/decrypt/duration/mean/{error_code:0&buffer_size:1024}".
virtual void SetString(const std::string& metric_id,
const std::string& value) = 0;
virtual void SetInt32(const std::string& metric_id, int32_t value) = 0;
virtual void SetInt64(const std::string& metric_id, int64_t value) = 0;
virtual void SetDouble(const std::string& metric_id, double value) = 0;
};
// This abstract class merely provides the definition for serializing the value
// of the metric.
class MetricSerializable {
public:
virtual ~MetricSerializable() { }
// Serialize metric values to the MetricSerializer. |serializer| must
// not be null and is owned by the caller.
virtual void Serialize(MetricSerializer* serializer) = 0;
};
} // namespace metrics
} // namespace wvcdm
#endif // WVCDM_METRICS_METRIC_SERIALIZATION_H_

171
libwvdrmengine/cdm/metrics/include/metrics_group.h → libwvdrmengine/cdm/metrics/include/metrics_collections.h
View File

@@ -1,4 +1,7 @@
// Copyright 2016 Google Inc. All Rights Reserved.
//
// This file contains definitions for metrics being collected throughout the
// CDM.
#ifndef WVCDM_METRICS_METRICS_GROUP_H_
#define WVCDM_METRICS_METRICS_GROUP_H_
@@ -6,14 +9,52 @@
#include <stddef.h>
#include <stdint.h>
#include "OEMCryptoCENC.h"
#include "event_metric.h"
#include "metric_publisher.h"
#include "OEMCryptoCENC.h"
#include "wv_cdm_types.h"
// This definition indicates that a given metric does not need timing
// stats. Example:
//
// M_RECORD(my_metrics, my_metric_name, NO_TIME);
#define NO_TIME 0
// Used to record metric timing and additional information about a specific
// event. Assumes that a microsecond timing has been provided. Example:
//
// long total_time = 0;
// long error_code = TimeSomeOperation(&total_time);
// M_RECORD(my_metrics, my_metric_name, total_time, error_code);
#define M_RECORD(GROUP, METRIC, TIME, ...) \
if ( GROUP ) { \
( GROUP ) -> METRIC . Record( TIME, ##__VA_ARGS__ ); \
}
// This definition automatically times an operation and records the time and
// additional information such as error code to the provided metric.
// Example:
//
// OEMCryptoResult sts;
// M_TIME(
// sts = OEMCrypto_Initialize(),
// my_metrics_collection,
// oemcrypto_initialize_,
// sts);
#define M_TIME(CALL, GROUP, METRIC, ...) \
if ( GROUP ) { \
wvcdm::metrics::TimerMetric timer; \
timer.Start(); \
CALL; \
( GROUP ) -> METRIC . Record(timer.AsUs(), ##__VA_ARGS__ ); \
} else { \
CALL; \
}
namespace wvcdm {
namespace metrics {
// This enum defines the conditions encountered during OEMCrypto Initialization
// in oemcrypto_adapter_dynamic.
typedef enum OEMCryptoInitializationMode {
OEMCrypto_INITIALIZED_USING_IN_APP = 0,
OEMCrypto_INITIALIZED_FORCING_L3 = 1,
@@ -33,35 +74,12 @@ typedef enum OEMCryptoInitializationMode {
OEMCrypto_INITIALIZED_USING_L1_WITH_PROVISIONING_3_0 = 15
} OEMCryptoInitializationMode;
/*
* The metrics group is the group of all metrics that be be recorded. They
* are kept together to allow calls to be correlated to one another.
*/
class MetricsGroup {
// This class contains metrics for Crypto Session and OEM Crypto.
class CryptoMetrics {
public:
/* CDM ENGINE */
EventMetric<CdmResponseType> cdm_engine_add_key_;
EventMetric<CdmResponseType> cdm_engine_close_session_;
EventMetric<CdmResponseType> cdm_engine_decrypt_;
EventMetric<bool> cdm_engine_find_session_for_key_;
EventMetric<CdmResponseType> cdm_engine_generate_key_request_;
EventMetric<CdmResponseType> cdm_engine_get_provisioning_request_;
EventMetric<CdmResponseType> cdm_engine_get_usage_info_;
EventMetric<CdmResponseType> cdm_engine_handle_provisioning_response_;
EventMetric<> cdm_engine_life_span_;
EventMetric<CdmResponseType> cdm_engine_open_key_set_session_;
EventMetric<CdmResponseType> cdm_engine_open_session_;
EventMetric<CdmResponseType> cdm_engine_query_key_status_;
EventMetric<CdmResponseType> cdm_engine_release_all_usage_info_;
EventMetric<CdmResponseType> cdm_engine_release_usage_info_;
EventMetric<CdmResponseType> cdm_engine_remove_keys_;
EventMetric<CdmResponseType> cdm_engine_restore_key_;
EventMetric<CdmResponseType, CdmSecurityLevel> cdm_engine_unprovision_;
/* CDM SESSION */
EventMetric<> cdm_session_life_span_;
EventMetric<CdmResponseType> cdm_session_renew_key_;
EventMetric<CdmResponseType> cdm_session_restore_offline_session_;
EventMetric<CdmResponseType> cdm_session_restore_usage_session_;
CryptoMetrics();
/* CRYPTO SESSION */
EventMetric<CdmResponseType> crypto_session_delete_all_usage_reports_;
EventMetric<CdmResponseType> crypto_session_delete_multiple_usage_information_;
@@ -127,14 +145,99 @@ class MetricsGroup {
/* Internal OEMCrypto Metrics */
EventMetric<OEMCryptoInitializationMode> oemcrypto_initialization_mode_;
EventMetric<uint32_t, uint32_t> oemcrypto_l1_api_version_;
};
MetricsGroup();
~MetricsGroup();
// This class contains session-scoped metrics. All properties and
// statistics related to operations within a single session are
// recorded here.
class SessionMetrics {
public:
SessionMetrics();
// Sets the session id of the metrics group. This allows the session
// id to be captured and reported as part of the collection of metrics.
void SetSessionId(const CdmSessionId& session_id) {
session_id_ = session_id; }
// Returns the session id or an empty session id if it has not been set.
const CdmSessionId& GetSessionId() const { return session_id_; }
// Marks the metrics object as completed and ready for serialization.
void SetCompleted() { completed_ = true; }
// Returns true if the object is completed. This is used to determine
// when the stats are ready to be published.
bool IsCompleted() const { return completed_; }
// Returns a pointer to the crypto metrics belonging to the engine instance.
// This instance retains ownership of the object.
CryptoMetrics* GetCryptoMetrics() { return &crypto_metrics_; }
// Metrics collected at the session level.
EventMetric<> cdm_session_life_span_;
EventMetric<CdmResponseType> cdm_session_renew_key_;
EventMetric<CdmResponseType> cdm_session_restore_offline_session_;
EventMetric<CdmResponseType> cdm_session_restore_usage_session_;
private:
void Publish(MetricNotification* subscriber);
CdmSessionId session_id_;
bool completed_;
CryptoMetrics crypto_metrics_;
};
// This class contains engine-scoped metrics. All properties and
// statistics related to operations within the engine, but outside
// the scope of a session are recorded here.
class EngineMetrics {
public:
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();
// 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);
// 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 all engine and completed session metrics to json format and
// send them to the output string. |out| must NOT be null. |completed_only|
// indicates that this call should only publish SessionMetrics instances
// that are marked as completed.
void JsonSerialize(std::string* out, bool completed_only);
// Metrics recorded at the engine level.
EventMetric<CdmResponseType> cdm_engine_add_key_;
EventMetric<CdmResponseType> cdm_engine_close_session_;
EventMetric<CdmResponseType> cdm_engine_decrypt_;
EventMetric<bool> cdm_engine_find_session_for_key_;
EventMetric<CdmResponseType> cdm_engine_generate_key_request_;
EventMetric<CdmResponseType> cdm_engine_get_provisioning_request_;
EventMetric<CdmResponseType> cdm_engine_get_usage_info_;
EventMetric<CdmResponseType> cdm_engine_handle_provisioning_response_;
EventMetric<> cdm_engine_life_span_;
EventMetric<CdmResponseType> cdm_engine_open_key_set_session_;
EventMetric<CdmResponseType> cdm_engine_open_session_;
EventMetric<CdmResponseType> cdm_engine_query_key_status_;
EventMetric<CdmResponseType> cdm_engine_release_all_usage_info_;
EventMetric<CdmResponseType> cdm_engine_release_usage_info_;
EventMetric<CdmResponseType> cdm_engine_remove_keys_;
EventMetric<CdmResponseType> cdm_engine_restore_key_;
EventMetric<CdmResponseType, CdmSecurityLevel> cdm_engine_unprovision_;
private:
Lock session_metrics_lock_;
std::vector<metrics::SessionMetrics*> session_metrics_list_;
CryptoMetrics crypto_metrics_;
};
} // namespace metrics
} // namespace wvcdm
#endif

58
libwvdrmengine/cdm/metrics/include/metrics_front_end.h
View File

@@ -1,58 +0,0 @@
// Copyright 2016 Google Inc. All Rights Reserved.
#ifndef WVCDM_METRICS_METRICS_FRONT_END_H_
#define WVCDM_METRICS_METRICS_FRONT_END_H_
#include <map>
#include "report.h"
#include "timer_metric.h" /* needed for the macro */
namespace wvcdm {
namespace metrics {
class MetricsFrontEnd {
public:
MetricsFrontEnd(Report* root);
MetricNotification* CreateSubscriber();
static MetricsFrontEnd& Instance();
static void OverrideInstance(MetricsFrontEnd* instance);
private:
static MetricsFrontEnd* instance_;
Report* root_;
/* Disallow copy and assign. */
MetricsFrontEnd(const MetricsFrontEnd&);
void operator=(const MetricsFrontEnd&);
};
} // namespace metrics
} // namespace wvcdm
#define MFE wvcdm::metrics::MetricsFrontEnd::Instance()
#define NO_TIME 0
#define M_RECORD(GROUP, METRIC, TIME, ...) \
if ( GROUP ) { \
( GROUP ) -> METRIC . Record( TIME, ##__VA_ARGS__ ); \
}
#define M_TIME(CALL, GROUP, METRIC, ...) \
if ( GROUP ) { \
wvcdm::metrics::TimerMetric timer; \
timer.Start(); \
CALL; \
( GROUP ) -> METRIC . Record(timer.AsUs(), ##__VA_ARGS__ ); \
} else { \
CALL; \
}
#endif

29
libwvdrmengine/cdm/metrics/include/report.h
View File

@@ -1,29 +0,0 @@
// Copyright 2016 Google Inc. All Rights Reserved.
#ifndef WVCDM_METRICS_REPORT_H_
#define WVCDM_METRICS_REPORT_H_
#include <stdint.h>
#include "event_metric.h"
namespace wvcdm {
namespace metrics {
class Report : public MetricNotification {
public:
virtual ~Report() { }
/* Create a new report of the same type. The new report is not
* a copy of this report. The pointer is to be owned by whoever
* calls this function. */
virtual Report* NewReport() const;
};
} // metrics
} //wvcdm
#endif

12
libwvdrmengine/cdm/metrics/src/event_metric.cpp
View File

@@ -32,24 +32,24 @@ void BaseEventMetric::Record(const std::string& field_names_values,
distribution->Record(value);
}
void BaseEventMetric::Publish(MetricNotification* notification) {
void BaseEventMetric::Serialize(MetricSerializer* serializer) {
AutoLock lock(internal_lock_);
for (std::map<std::string, Distribution*>::iterator it
= value_map_.begin(); it != value_map_.end(); it++) {
notification->UpdateInt64(
serializer->SetInt64(
metric_name_ + "/count" + it->first,
it->second->Count());
notification->UpdateDouble(
serializer->SetDouble(
metric_name_ + "/mean" + it->first,
it->second->Mean());
notification->UpdateDouble(
serializer->SetDouble(
metric_name_ + "/variance" + it->first,
it->second->Variance());
notification->UpdateDouble(
serializer->SetDouble(
metric_name_ + "/min" + it->first,
it->second->Min());
notification->UpdateDouble(
serializer->SetDouble(
metric_name_ + "/max" + it->first,
it->second->Max());
}

267
libwvdrmengine/cdm/metrics/src/metrics_group.cpp → libwvdrmengine/cdm/metrics/src/metrics_collections.cpp
View File

@@ -1,75 +1,27 @@
// Copyright 2016 Google Inc. All Rights Reserved.
#include "metrics_group.h"
#include "metrics_collections.h"
#include "metrics_front_end.h"
#include <algorithm>
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 {
return metrics->GetSessionId() == target_;
}
};
} // anonymous namespace
namespace wvcdm {
namespace metrics {
MetricsGroup::MetricsGroup() :
cdm_engine_add_key_(
"/drm/widevine/cdm_engine/add_key/time",
"error"),
cdm_engine_close_session_(
"/drm/widevine/cdm_engine/close_session/time",
"error"),
cdm_engine_decrypt_(
"/drm/widevine/cdm_engine/decrypt/time",
"error"),
cdm_engine_find_session_for_key_(
"/drm/widevine/cdm_engine/find_session_for_key/time",
"success"),
cdm_engine_generate_key_request_(
"/drm/widevine/cdm_engine/generate_key_request/time",
"error"),
cdm_engine_get_provisioning_request_(
"/drm/widevine/cdm_engine/get_provisioning_request/time",
"error"),
cdm_engine_get_usage_info_(
"/drm/widevine/cdm_engine/get_usage_info/time",
"error"),
cdm_engine_handle_provisioning_response_(
"/drm/widevine/cdm_engine/handle_provisioning_response/time",
"error"),
cdm_engine_life_span_(
"/drm/widevine/cdm_engine/life_span/time"),
cdm_engine_open_key_set_session_(
"/drm/widevine/cdm_engine/open_key_set_session/time",
"error"),
cdm_engine_open_session_(
"/drm/widevine/cdm_engine/open_session/time",
"error"),
cdm_engine_query_key_status_(
"/drm/widevine/cdm_engine/query_key_status/time",
"error"),
cdm_engine_release_all_usage_info_(
"/drm/widevine/cdm_engine/release_all_usage_info/time",
"error"),
cdm_engine_release_usage_info_(
"/drm/widevine/cdm_engine/release_usage_info/time",
"error"),
cdm_engine_remove_keys_(
"/drm/widevine/cdm_engine/remove_keys/time",
"error"),
cdm_engine_restore_key_(
"/drm/widevine/cdm_engine/restore_key/time",
"error"),
cdm_engine_unprovision_(
"/drm/widevine/cdm_engine/unprovision/time",
"error",
"security_level"),
cdm_session_life_span_(
"/drm/widevine/cdm_session/life_span/time"),
cdm_session_renew_key_(
"/drm/widevine/cdm_session/renew_key/time",
"error"),
cdm_session_restore_offline_session_(
"/drm/widevine/cdm_session/restore_offline_session/time",
"error"),
cdm_session_restore_usage_session_(
"/drm/widevine/cdm_session/restore_usage_session/time",
"error"),
CryptoMetrics::CryptoMetrics() :
crypto_session_delete_all_usage_reports_(
"/drm/widevine/crypto_session/delete_all_usage_reports/time",
"error"),
@@ -287,99 +239,106 @@ MetricsGroup::MetricsGroup() :
oemcrypto_l1_api_version_(
"/drm/widevine/oemcrypto/l1_api_version",
"version",
"min_version") { }
"min_version") {}
MetricsGroup::~MetricsGroup() {
#if 0 // Disable metrics for now to work around P0:b/35093325
MetricNotification* subscriber = MFE.CreateSubscriber();
if (subscriber) {
Publish(subscriber);
SessionMetrics::SessionMetrics() :
cdm_session_life_span_(
"/drm/widevine/cdm_session/life_span/time"),
cdm_session_renew_key_(
"/drm/widevine/cdm_session/renew_key/time",
"error"),
cdm_session_restore_offline_session_(
"/drm/widevine/cdm_session/restore_offline_session/time",
"error"),
cdm_session_restore_usage_session_(
"/drm/widevine/cdm_session/restore_usage_session/time",
"error"),
completed_(false) {
}
EngineMetrics::EngineMetrics() :
cdm_engine_add_key_(
"/drm/widevine/cdm_engine/add_key/time",
"error"),
cdm_engine_close_session_(
"/drm/widevine/cdm_engine/close_session/time",
"error"),
cdm_engine_decrypt_(
"/drm/widevine/cdm_engine/decrypt/time",
"error"),
cdm_engine_find_session_for_key_(
"/drm/widevine/cdm_engine/find_session_for_key/time",
"success"),
cdm_engine_generate_key_request_(
"/drm/widevine/cdm_engine/generate_key_request/time",
"error"),
cdm_engine_get_provisioning_request_(
"/drm/widevine/cdm_engine/get_provisioning_request/time",
"error"),
cdm_engine_get_usage_info_(
"/drm/widevine/cdm_engine/get_usage_info/time",
"error"),
cdm_engine_handle_provisioning_response_(
"/drm/widevine/cdm_engine/handle_provisioning_response/time",
"error"),
cdm_engine_life_span_(
"/drm/widevine/cdm_engine/life_span/time"),
cdm_engine_open_key_set_session_(
"/drm/widevine/cdm_engine/open_key_set_session/time",
"error"),
cdm_engine_open_session_(
"/drm/widevine/cdm_engine/open_session/time",
"error"),
cdm_engine_query_key_status_(
"/drm/widevine/cdm_engine/query_key_status/time",
"error"),
cdm_engine_release_all_usage_info_(
"/drm/widevine/cdm_engine/release_all_usage_info/time",
"error"),
cdm_engine_release_usage_info_(
"/drm/widevine/cdm_engine/release_usage_info/time",
"error"),
cdm_engine_remove_keys_(
"/drm/widevine/cdm_engine/remove_keys/time",
"error"),
cdm_engine_restore_key_(
"/drm/widevine/cdm_engine/restore_key/time",
"error"),
cdm_engine_unprovision_(
"/drm/widevine/cdm_engine/unprovision/time",
"error",
"security_level") {
}
EngineMetrics::~EngineMetrics() {
AutoLock kock(session_metrics_lock_);
std::vector<SessionMetrics*>::iterator i;
for (i = session_metrics_list_.begin(); i != session_metrics_list_.end();
i++) {
delete *i;
}
delete subscriber;
#endif
session_metrics_list_.clear();
}
void MetricsGroup::Publish(MetricNotification* subscriber) {
cdm_engine_add_key_.Publish(subscriber);
cdm_engine_close_session_.Publish(subscriber);
cdm_engine_decrypt_.Publish(subscriber);
cdm_engine_find_session_for_key_.Publish(subscriber);
cdm_engine_generate_key_request_.Publish(subscriber);
cdm_engine_get_provisioning_request_.Publish(subscriber);
cdm_engine_get_usage_info_.Publish(subscriber);
cdm_engine_handle_provisioning_response_.Publish(subscriber);
cdm_engine_life_span_.Publish(subscriber);
cdm_engine_open_key_set_session_.Publish(subscriber);
cdm_engine_open_session_.Publish(subscriber);
cdm_engine_query_key_status_.Publish(subscriber);
cdm_engine_release_all_usage_info_.Publish(subscriber);
cdm_engine_release_usage_info_.Publish(subscriber);
cdm_engine_remove_keys_.Publish(subscriber);
cdm_engine_restore_key_.Publish(subscriber);
cdm_engine_unprovision_.Publish(subscriber);
cdm_session_life_span_.Publish(subscriber);
cdm_session_renew_key_.Publish(subscriber);
cdm_session_restore_offline_session_.Publish(subscriber);
cdm_session_restore_usage_session_.Publish(subscriber);
crypto_session_delete_all_usage_reports_.Publish(subscriber);
crypto_session_delete_multiple_usage_information_.Publish(subscriber);
crypto_session_generic_decrypt_.Publish(subscriber);
crypto_session_generic_sign_.Publish(subscriber);
crypto_session_generic_verify_.Publish(subscriber);
crypto_session_get_device_unique_id_.Publish(subscriber);
crypto_session_get_security_level_.Publish(subscriber);
crypto_session_get_system_id_.Publish(subscriber);
crypto_session_get_token_.Publish(subscriber);
crypto_session_life_span_.Publish(subscriber);
crypto_session_load_certificate_private_key_.Publish(subscriber);
crypto_session_open_.Publish(subscriber);
crypto_session_update_usage_information_.Publish(subscriber);
crypto_session_usage_information_support_.Publish(subscriber);
oemcrypto_api_version_.Publish(subscriber);
oemcrypto_close_session_.Publish(subscriber);
oemcrypto_copy_buffer_.Publish(subscriber);
oemcrypto_deactivate_usage_entry_.Publish(subscriber);
oemcrypto_decrypt_cenc_.Publish(subscriber);
oemcrypto_delete_usage_entry_.Publish(subscriber);
oemcrypto_delete_usage_table_.Publish(subscriber);
oemcrypto_derive_keys_from_session_key_.Publish(subscriber);
oemcrypto_force_delete_usage_entry_.Publish(subscriber);
oemcrypto_generate_derived_keys_.Publish(subscriber);
oemcrypto_generate_nonce_.Publish(subscriber);
oemcrypto_generate_rsa_signature_.Publish(subscriber);
oemcrypto_generate_signature_.Publish(subscriber);
oemcrypto_generic_decrypt_.Publish(subscriber);
oemcrypto_generic_encrypt_.Publish(subscriber);
oemcrypto_generic_sign_.Publish(subscriber);
oemcrypto_generic_verify_.Publish(subscriber);
oemcrypto_get_device_id_.Publish(subscriber);
oemcrypto_get_hdcp_capability_.Publish(subscriber);
oemcrypto_get_key_data_.Publish(subscriber);
oemcrypto_get_max_number_of_sessions_.Publish(subscriber);
oemcrypto_get_number_of_open_sessions_.Publish(subscriber);
oemcrypto_get_oem_public_certificate_.Publish(subscriber);
oemcrypto_get_provisioning_method_.Publish(subscriber);
oemcrypto_get_random_.Publish(subscriber);
oemcrypto_install_keybox_.Publish(subscriber);
oemcrypto_is_anti_rollback_hw_present_.Publish(subscriber);
oemcrypto_is_keybox_valid_.Publish(subscriber);
oemcrypto_load_device_rsa_key_.Publish(subscriber);
oemcrypto_load_keys_.Publish(subscriber);
oemcrypto_load_test_keybox_.Publish(subscriber);
oemcrypto_load_test_rsa_key_.Publish(subscriber);
oemcrypto_open_session_.Publish(subscriber);
oemcrypto_refresh_keys_.Publish(subscriber);
oemcrypto_report_usage_.Publish(subscriber);
oemcrypto_rewrap_device_rsa_key_.Publish(subscriber);
oemcrypto_rewrap_device_rsa_key_30_.Publish(subscriber);
oemcrypto_security_level_.Publish(subscriber);
oemcrypto_security_patch_level_.Publish(subscriber);
oemcrypto_select_key_.Publish(subscriber);
oemcrypto_supports_usage_table_.Publish(subscriber);
oemcrypto_update_usage_table_.Publish(subscriber);
oemcrypto_wrap_keybox_.Publish(subscriber);
oemcrypto_initialization_mode_.Publish(subscriber);
oemcrypto_l1_api_version_.Publish(subscriber);
SessionMetrics* EngineMetrics::AddSession() {
AutoLock lock(session_metrics_lock_);
SessionMetrics* metrics = new SessionMetrics();
session_metrics_list_.push_back(metrics);
return metrics;
}
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(),
CompareSessionIds(session_id)),
session_metrics_list_.end());
}
void JsonSerialize(std::string* out, bool completed_only) {
// TODO(blueeyes): Implement this.
}
} // metrics
} // wvcdm

31
libwvdrmengine/cdm/metrics/src/metrics_front_end.cpp
View File

@@ -1,31 +0,0 @@
// Copyright 2016 Google Inc. All Rights Reserved
#include "metrics_front_end.h"
#include <stddef.h>
#include <log.h>
namespace wvcdm {
namespace metrics {
MetricsFrontEnd* MetricsFrontEnd::instance_ = NULL;
MetricsFrontEnd::MetricsFrontEnd(Report* root) :
root_(root) { }
MetricNotification* MetricsFrontEnd::CreateSubscriber() {
return root_ == NULL ? NULL : root_->NewReport();
}
MetricsFrontEnd& MetricsFrontEnd::Instance() {
static MetricsFrontEnd kDummy(NULL);
return instance_ == NULL ? kDummy : *instance_;
}
void MetricsFrontEnd::OverrideInstance(MetricsFrontEnd* instance) {
instance_ = instance;
}
} // namespace metrics
} // namespace wvcdm

60
libwvdrmengine/cdm/metrics/test/event_metric_test.cpp
View File

@@ -3,7 +3,7 @@
// Unit tests for EventMetric
#include "event_metric.h"
#include "metric_publisher.h"
#include "metric_serialization.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
@@ -15,22 +15,22 @@ using testing::NotNull;
namespace wvcdm {
namespace metrics {
class MockEventMetricNotification : public MetricNotification {
class MockEventMetricSerializer : public MetricSerializer {
public:
MOCK_METHOD2(UpdateString, void(const std::string& metric_id,
MOCK_METHOD2(SetString, void(const std::string& metric_id,
const std::string& value));
MOCK_METHOD2(UpdateInt32, void(const std::string& metric_id,
MOCK_METHOD2(SetInt32, void(const std::string& metric_id,
int32_t value));
MOCK_METHOD2(UpdateInt64, void(const std::string& metric_id,
MOCK_METHOD2(SetInt64, void(const std::string& metric_id,
int64_t value));
MOCK_METHOD2(UpdateDouble, void(const std::string& metric_id,
MOCK_METHOD2(SetDouble, void(const std::string& metric_id,
double value));
};
class EventMetricTest : public ::testing::Test {
public:
void SetUp() {
mock_notification_.reset(new MockEventMetricNotification());
mock_serializer_.reset(new MockEventMetricSerializer());
}
protected:
template<typename F1,
@@ -44,7 +44,7 @@ class EventMetricTest : public ::testing::Test {
return metric.value_map_;
}
scoped_ptr<MockEventMetricNotification> mock_notification_;
scoped_ptr<MockEventMetricSerializer> mock_serializer_;
};
TEST_F(EventMetricTest, NoFieldsSuccessNullCallback) {
@@ -60,19 +60,19 @@ TEST_F(EventMetricTest, NoFieldsSuccessNullCallback) {
TEST_F(EventMetricTest, NoFieldsSuccessWithCallback) {
wvcdm::metrics::EventMetric<> metric("no/fields/metric");
EXPECT_CALL(*mock_notification_,
UpdateInt64("no/fields/metric/count", 1.0));
EXPECT_CALL(*mock_notification_,
UpdateDouble("no/fields/metric/mean", 10.0));
EXPECT_CALL(*mock_notification_,
UpdateDouble("no/fields/metric/variance", 0.0));
EXPECT_CALL(*mock_notification_,
UpdateDouble("no/fields/metric/min", 10.0));
EXPECT_CALL(*mock_notification_,
UpdateDouble("no/fields/metric/max", 10.0));
EXPECT_CALL(*mock_serializer_,
SetInt64("no/fields/metric/count", 1.0));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/mean", 10.0));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/variance", 0.0));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/min", 10.0));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/max", 10.0));
metric.Record(10);
metric.Publish(mock_notification_.get());
metric.Serialize(mock_serializer_.get());
std::map<std::string, Distribution*> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
@@ -142,24 +142,24 @@ TEST_F(EventMetricTest, TwoFieldsSuccessWithCallback) {
// Callbacks from second record operation.
EXPECT_CALL(
*mock_notification_,
UpdateInt64("two/fields/metric/count{error_code:11&pow2_size:16}", 2.0));
*mock_serializer_,
SetInt64("two/fields/metric/count{error_code:11&pow2_size:16}", 2.0));
EXPECT_CALL(
*mock_notification_,
UpdateDouble("two/fields/metric/mean{error_code:11&pow2_size:16}", 3.5));
*mock_serializer_,
SetDouble("two/fields/metric/mean{error_code:11&pow2_size:16}", 3.5));
EXPECT_CALL(
*mock_notification_,
UpdateDouble("two/fields/metric/variance{error_code:11&pow2_size:16}",
*mock_serializer_,
SetDouble("two/fields/metric/variance{error_code:11&pow2_size:16}",
0.25));
EXPECT_CALL(
*mock_notification_,
UpdateDouble("two/fields/metric/min{error_code:11&pow2_size:16}", 3.0));
*mock_serializer_,
SetDouble("two/fields/metric/min{error_code:11&pow2_size:16}", 3.0));
EXPECT_CALL(
*mock_notification_,
UpdateDouble("two/fields/metric/max{error_code:11&pow2_size:16}", 4.0));
*mock_serializer_,
SetDouble("two/fields/metric/max{error_code:11&pow2_size:16}", 4.0));
metric.Record(3, 11, Pow2Bucket(29));
metric.Record(4, 11, Pow2Bucket(29));
metric.Publish(mock_notification_.get());
metric.Serialize(mock_serializer_.get());
}
TEST_F(EventMetricTest, ThreeFieldsSuccess) {