From a4760e939fe40138e6591093a3ec128ab0d29962 Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 2 May 2017 00:07:46 -0400 Subject: [PATCH] common: Add a generic interface for logging telemetry fields. --- src/common/CMakeLists.txt | 2 + src/common/telemetry.cpp | 40 ++++++++ src/common/telemetry.h | 196 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 238 insertions(+) create mode 100644 src/common/telemetry.cpp create mode 100644 src/common/telemetry.h diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt index 4b30185f1..6905d2d50 100644 --- a/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt @@ -38,6 +38,7 @@ set(SRCS param_package.cpp scm_rev.cpp string_util.cpp + telemetry.cpp thread.cpp timer.cpp ) @@ -74,6 +75,7 @@ set(HEADERS string_util.h swap.h synchronized_wrapper.h + telemetry.h thread.h thread_queue_list.h timer.h diff --git a/src/common/telemetry.cpp b/src/common/telemetry.cpp new file mode 100644 index 000000000..bf1f54886 --- /dev/null +++ b/src/common/telemetry.cpp @@ -0,0 +1,40 @@ +// Copyright 2017 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include +#include "common/telemetry.h" + +namespace Telemetry { + +void FieldCollection::Accept(VisitorInterface& visitor) const { + for (const auto& field : fields) { + field.second->Accept(visitor); + } +} + +void FieldCollection::AddField(std::unique_ptr field) { + fields[field->GetName()] = std::move(field); +} + +template +void Field::Accept(VisitorInterface& visitor) const { + visitor.Visit(*this); +} + +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; +template class Field; + +} // namespace Telemetry diff --git a/src/common/telemetry.h b/src/common/telemetry.h new file mode 100644 index 000000000..dd6bbd759 --- /dev/null +++ b/src/common/telemetry.h @@ -0,0 +1,196 @@ +// Copyright 2017 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include +#include +#include +#include +#include "common/common_types.h" + +namespace Telemetry { + +/// Field type, used for grouping fields together in the final submitted telemetry log +enum class FieldType : u8 { + None = 0, ///< No specified field group + App, ///< Citra application fields (e.g. version, branch, etc.) + Session, ///< Emulated session fields (e.g. title ID, log, etc.) + Performance, ///< Emulated performance (e.g. fps, emulated CPU speed, etc.) + UserFeedback, ///< User submitted feedback (e.g. star rating, user notes, etc.) + UserConfig, ///< User configuration fields (e.g. emulated CPU core, renderer, etc.) + UserSystem, ///< User system information (e.g. host CPU type, RAM, etc.) +}; + +struct VisitorInterface; + +/** + * Interface class for telemetry data fields. + */ +class FieldInterface : NonCopyable { +public: + virtual ~FieldInterface() = default; + + /** + * Accept method for the visitor pattern. + * @param visitor Reference to the visitor that will visit this field. + */ + virtual void Accept(VisitorInterface& visitor) const = 0; + + /** + * Gets the name of this field. + * @returns Name of this field as a string. + */ + virtual const std::string& GetName() const = 0; +}; + +/** + * Represents a telemetry data field, i.e. a unit of data that gets logged and submitted to our + * telemetry web service. + */ +template +class Field : public FieldInterface { +public: + Field(FieldType type, std::string name, const T& value) + : type(type), name(std::move(name)), value(value) {} + + Field(FieldType type, std::string name, T&& value) + : type(type), name(std::move(name)), value(std::move(value)) {} + + Field(const Field& other) : Field(other.type, other.name, other.value) {} + + Field& operator=(const Field& other) { + type = other.type; + name = other.name; + value = other.value; + return *this; + } + + Field& operator=(Field&& other) { + type = other.type; + name = std::move(other.name); + value = std::move(other.value); + return *this; + } + + void Accept(VisitorInterface& visitor) const override; + + const std::string& GetName() const override { + return name; + } + + /** + * Returns the type of the field. + */ + FieldType GetType() const { + return type; + } + + /** + * Returns the value of the field. + */ + const T& GetValue() const { + return value; + } + + inline bool operator==(const Field& other) { + return (type == other.type) && (name == other.name) && (value == other.value); + } + + inline bool operator!=(const Field& other) { + return !(*this == other); + } + +private: + std::string name; ///< Field name, must be unique + FieldType type{}; ///< Field type, used for grouping fields together + T value; ///< Field value +}; + +/** + * Collection of data fields that have been logged. + */ +class FieldCollection final : NonCopyable { +public: + FieldCollection() = default; + + /** + * Accept method for the visitor pattern, visits each field in the collection. + * @param visitor Reference to the visitor that will visit each field. + */ + void Accept(VisitorInterface& visitor) const; + + /** + * Creates a new field and adds it to the field collection. + * @param type Type of the field to add. + * @param name Name of the field to add. + * @param value Value for the field to add. + */ + template + void AddField(FieldType type, const char* name, T value) { + return AddField(std::make_unique>(type, name, std::move(value))); + } + + /** + * Adds a new field to the field collection. + * @param field Field to add to the field collection. + */ + void AddField(std::unique_ptr field); + +private: + std::map> fields; +}; + +/** + * Telemetry fields visitor interface class. A backend to log to a web service should implement + * this interface. + */ +struct VisitorInterface : NonCopyable { + virtual ~VisitorInterface() = default; + + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + virtual void Visit(const Field& field) = 0; + + /// Completion method, called once all fields have been visited + virtual void Complete() = 0; +}; + +/** + * Empty implementation of VisitorInterface that drops all fields. Used when a functional + * backend implementation is not available. + */ +struct NullVisitor : public VisitorInterface { + ~NullVisitor() = default; + + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + void Visit(const Field& /*field*/) override {} + + void Complete() override {} +}; + +} // namespace Telemetry