429 lines
11 KiB
C++
429 lines
11 KiB
C++
/*!********************************************************************
|
|
|
|
Audacity: A Digital Audio Editor
|
|
|
|
@file SentryReport.cpp
|
|
@brief Define a class to report errors to Sentry.
|
|
|
|
Dmitry Vedenko
|
|
**********************************************************************/
|
|
|
|
#include "SentryReport.h"
|
|
|
|
#include <chrono>
|
|
#include <cstring>
|
|
#include <mutex>
|
|
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
#include <regex>
|
|
|
|
#include <rapidjson/document.h>
|
|
#include <rapidjson/writer.h>
|
|
#include <rapidjson/prettywriter.h>
|
|
|
|
#include <wx/platinfo.h>
|
|
#include <wx/log.h>
|
|
|
|
#include "CodeConversions.h"
|
|
#include "Uuid.h"
|
|
|
|
#include "IResponse.h"
|
|
#include "NetworkManager.h"
|
|
|
|
#include "SentryRequestBuilder.h"
|
|
|
|
namespace audacity
|
|
{
|
|
namespace sentry
|
|
{
|
|
namespace
|
|
{
|
|
|
|
//! Helper class to store additional details about the exception
|
|
/*! This small class is a thread safe store for the information
|
|
we want to add to the exception before the exception occurs.
|
|
For example, we may log SQLite3 return codes here, as otherwise
|
|
they wont be available when everything fails
|
|
*/
|
|
class ExceptionContext final
|
|
{
|
|
public:
|
|
//! Adds a new item to the exception context
|
|
void Add(std::string parameterName, AnonymizedMessage parameterValue)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mDataMutex);
|
|
mData.emplace_back(std::move(parameterName), std::move(parameterValue));
|
|
}
|
|
|
|
//! Return the current context and reset it
|
|
std::vector<ExceptionData> MoveParameters()
|
|
{
|
|
std::lock_guard<std::mutex> lock(mDataMutex);
|
|
|
|
std::vector<ExceptionData> emptyVector;
|
|
|
|
std::swap(mData, emptyVector);
|
|
|
|
return emptyVector;
|
|
}
|
|
|
|
//! Get an instance of the ExceptionContext
|
|
static ExceptionContext& Get()
|
|
{
|
|
static ExceptionContext instance;
|
|
return instance;
|
|
}
|
|
|
|
private:
|
|
ExceptionContext() = default;
|
|
|
|
std::mutex mDataMutex;
|
|
std::vector<ExceptionData> mData;
|
|
};
|
|
|
|
//! Append the data about the operating system to the JSON document
|
|
void AddOSContext(
|
|
rapidjson::Value& root, rapidjson::Document::AllocatorType& allocator)
|
|
{
|
|
rapidjson::Value osContext(rapidjson::kObjectType);
|
|
|
|
const wxPlatformInfo platformInfo = wxPlatformInfo::Get();
|
|
|
|
const std::string osName =
|
|
ToUTF8(platformInfo.GetOperatingSystemFamilyName());
|
|
|
|
osContext.AddMember("type", rapidjson::Value("os", allocator), allocator);
|
|
|
|
osContext.AddMember(
|
|
"name", rapidjson::Value(osName.c_str(), osName.length(), allocator),
|
|
allocator);
|
|
|
|
const std::string osVersion =
|
|
std::to_string(platformInfo.GetOSMajorVersion()) + "." +
|
|
std::to_string(platformInfo.GetOSMinorVersion()) + "." +
|
|
std::to_string(platformInfo.GetOSMicroVersion());
|
|
|
|
osContext.AddMember(
|
|
"version",
|
|
rapidjson::Value(osVersion.c_str(), osVersion.length(), allocator),
|
|
allocator);
|
|
|
|
root.AddMember("os", std::move(osContext), allocator);
|
|
}
|
|
|
|
//! Create the minimal required Sentry JSON document
|
|
rapidjson::Document CreateSentryDocument()
|
|
{
|
|
using namespace std::chrono;
|
|
rapidjson::Document document;
|
|
|
|
document.SetObject();
|
|
|
|
document.AddMember(
|
|
"timestamp",
|
|
rapidjson::Value(
|
|
duration_cast<seconds>(system_clock::now().time_since_epoch())
|
|
.count()),
|
|
document.GetAllocator());
|
|
|
|
std::string eventId = Uuid::Generate().ToHexString();
|
|
|
|
document.AddMember(
|
|
"event_id",
|
|
rapidjson::Value(
|
|
eventId.c_str(), eventId.length(), document.GetAllocator()),
|
|
document.GetAllocator());
|
|
|
|
constexpr char platform[] = "native";
|
|
|
|
document.AddMember(
|
|
"platform",
|
|
rapidjson::Value(platform, sizeof(platform) - 1, document.GetAllocator()),
|
|
document.GetAllocator());
|
|
|
|
document["platform"].SetString(
|
|
platform, sizeof(platform) - 1, document.GetAllocator());
|
|
|
|
const std::string release = std::string("audacity@") +
|
|
std::to_string(AUDACITY_VERSION) + "." +
|
|
std::to_string(AUDACITY_RELEASE) + "." +
|
|
std::to_string(AUDACITY_REVISION);
|
|
|
|
document.AddMember(
|
|
"release",
|
|
rapidjson::Value(
|
|
release.c_str(), release.length(), document.GetAllocator()),
|
|
document.GetAllocator());
|
|
|
|
rapidjson::Value contexts = rapidjson::Value(rapidjson::kObjectType);
|
|
|
|
AddOSContext(contexts, document.GetAllocator());
|
|
|
|
document.AddMember("contexts", contexts, document.GetAllocator());
|
|
|
|
return document;
|
|
}
|
|
|
|
//! Append the ExceptionData to the Exception JSON object
|
|
void AddExceptionDataToJson(
|
|
rapidjson::Value& value, rapidjson::Document::AllocatorType& allocator,
|
|
const ExceptionData& data)
|
|
{
|
|
value.AddMember(
|
|
rapidjson::Value(data.first.c_str(), data.first.length(), allocator),
|
|
rapidjson::Value(data.second.c_str(), data.second.length(), allocator),
|
|
allocator);
|
|
}
|
|
|
|
//! Serialize the Exception to JSON
|
|
void SerializeException(
|
|
const Exception& exception, rapidjson::Value& root,
|
|
rapidjson::Document::AllocatorType& allocator)
|
|
{
|
|
root.AddMember(
|
|
"type",
|
|
rapidjson::Value(
|
|
exception.Type.c_str(), exception.Type.length(), allocator),
|
|
allocator);
|
|
|
|
root.AddMember(
|
|
"value",
|
|
rapidjson::Value(
|
|
exception.Value.c_str(), exception.Value.length(), allocator),
|
|
allocator);
|
|
|
|
rapidjson::Value mechanismObject(rapidjson::kObjectType);
|
|
|
|
mechanismObject.AddMember(
|
|
"type", rapidjson::Value("runtime_error", allocator), allocator);
|
|
|
|
mechanismObject.AddMember(
|
|
"handled", false, allocator);
|
|
|
|
auto contextData = ExceptionContext::Get().MoveParameters();
|
|
|
|
if (!exception.Data.empty() || !contextData.empty())
|
|
{
|
|
rapidjson::Value dataObject(rapidjson::kObjectType);
|
|
|
|
for (const auto& data : contextData)
|
|
AddExceptionDataToJson(dataObject, allocator, data);
|
|
|
|
for (const auto& data : exception.Data)
|
|
AddExceptionDataToJson(dataObject, allocator, data);
|
|
|
|
mechanismObject.AddMember("data", std::move(dataObject), allocator);
|
|
}
|
|
|
|
root.AddMember("mechanism", std::move(mechanismObject), allocator);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
Exception Exception::Create(std::string type, AnonymizedMessage value)
|
|
{
|
|
std::replace_if(type.begin(), type.end(), [](char c) {
|
|
return std::isspace(c) != 0;
|
|
}, '_');
|
|
|
|
return { std::move(type), std::move(value) };
|
|
}
|
|
|
|
Exception Exception::Create(AnonymizedMessage value)
|
|
{
|
|
return { "runtime_error", std::move(value) };
|
|
}
|
|
|
|
Exception& Exception::AddData(std::string key, AnonymizedMessage value)
|
|
{
|
|
Data.emplace_back(std::move(key), std::move(value));
|
|
return *this;
|
|
}
|
|
|
|
Message Message::Create(AnonymizedMessage message)
|
|
{
|
|
return { std::move(message) };
|
|
}
|
|
|
|
Message& Message::AddParam(AnonymizedMessage value)
|
|
{
|
|
Params.emplace_back(std::move(value));
|
|
return *this;
|
|
}
|
|
|
|
void AddExceptionContext(
|
|
std::string parameterName, AnonymizedMessage parameterValue)
|
|
{
|
|
ExceptionContext::Get().Add(std::move (parameterName), std::move (parameterValue));
|
|
}
|
|
|
|
class Report::ReportImpl
|
|
{
|
|
public:
|
|
explicit ReportImpl(const Exception& exception);
|
|
explicit ReportImpl(const Message& message);
|
|
|
|
void AddUserComment(const std::string& message);
|
|
|
|
std::string ToString(bool pretty) const;
|
|
|
|
void Send(CompletionHandler completionHandler) const;
|
|
|
|
private:
|
|
rapidjson::Document mDocument;
|
|
};
|
|
|
|
|
|
Report::ReportImpl::ReportImpl(const Exception& exception)
|
|
: mDocument(CreateSentryDocument())
|
|
{
|
|
rapidjson::Value exceptionObject(rapidjson::kObjectType);
|
|
rapidjson::Value valuesArray(rapidjson::kArrayType);
|
|
rapidjson::Value valueObject(rapidjson::kObjectType);
|
|
|
|
SerializeException(exception, valueObject, mDocument.GetAllocator());
|
|
|
|
valuesArray.PushBack(std::move(valueObject), mDocument.GetAllocator());
|
|
|
|
exceptionObject.AddMember(
|
|
"values", std::move(valuesArray), mDocument.GetAllocator());
|
|
|
|
mDocument.AddMember(
|
|
"exception", std::move(exceptionObject), mDocument.GetAllocator());
|
|
}
|
|
|
|
Report::ReportImpl::ReportImpl(const Message& message)
|
|
: mDocument(CreateSentryDocument())
|
|
{
|
|
rapidjson::Value messageObject(rapidjson::kObjectType);
|
|
|
|
messageObject.AddMember(
|
|
"message",
|
|
rapidjson::Value(
|
|
message.Value.c_str(), message.Value.length(),
|
|
mDocument.GetAllocator()),
|
|
mDocument.GetAllocator());
|
|
|
|
if (!message.Params.empty())
|
|
{
|
|
rapidjson::Value paramsArray(rapidjson::kArrayType);
|
|
|
|
for (const AnonymizedMessage& param : message.Params)
|
|
{
|
|
paramsArray.PushBack(
|
|
rapidjson::Value(
|
|
param.c_str(), param.length(), mDocument.GetAllocator()),
|
|
mDocument.GetAllocator());
|
|
}
|
|
|
|
messageObject.AddMember(
|
|
"params", std::move(paramsArray), mDocument.GetAllocator());
|
|
}
|
|
|
|
mDocument.AddMember(
|
|
"message", std::move(messageObject), mDocument.GetAllocator());
|
|
}
|
|
|
|
void Report::ReportImpl::AddUserComment(const std::string& message)
|
|
{
|
|
// We only allow adding comment to exceptions now
|
|
if (!mDocument.HasMember("exception") || message.empty())
|
|
return;
|
|
|
|
rapidjson::Value& topException = mDocument["exception"]["values"][0];
|
|
|
|
if (!topException.IsObject())
|
|
return;
|
|
|
|
rapidjson::Value& mechanism = topException["mechanism"];
|
|
|
|
// Create a data object if it still does not exist
|
|
if (!mechanism.HasMember("data"))
|
|
{
|
|
mechanism.AddMember(
|
|
"data", rapidjson::Value(rapidjson::kObjectType),
|
|
mDocument.GetAllocator());
|
|
}
|
|
|
|
// Add a comment itself
|
|
mechanism["data"].AddMember(
|
|
"user_comment",
|
|
rapidjson::Value(
|
|
message.data(), message.length(), mDocument.GetAllocator()),
|
|
mDocument.GetAllocator());
|
|
}
|
|
|
|
|
|
void Report::ReportImpl::Send(CompletionHandler completionHandler) const
|
|
{
|
|
const std::string serializedDocument = ToString(false);
|
|
|
|
network_manager::Request request =
|
|
SentryRequestBuilder::Get().CreateRequest();
|
|
|
|
auto response = network_manager::NetworkManager::GetInstance().doPost(
|
|
request, serializedDocument.data(), serializedDocument.size());
|
|
|
|
response->setRequestFinishedCallback(
|
|
[response, handler = std::move(completionHandler)](network_manager::IResponse*) {
|
|
const std::string responseData = response->readAll<std::string>();
|
|
|
|
wxLogDebug(responseData.c_str());
|
|
|
|
if (handler)
|
|
handler(response->getHTTPCode(), responseData);
|
|
});
|
|
}
|
|
|
|
std::string Report::ReportImpl::ToString(bool pretty) const
|
|
{
|
|
rapidjson::StringBuffer buffer;
|
|
|
|
if (pretty)
|
|
{
|
|
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
|
|
mDocument.Accept(writer);
|
|
}
|
|
else
|
|
{
|
|
rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
|
|
mDocument.Accept(writer);
|
|
}
|
|
|
|
return std::string(buffer.GetString());
|
|
}
|
|
|
|
Report::~Report()
|
|
{
|
|
}
|
|
|
|
Report::Report(const Exception& exception)
|
|
: mImpl(std::make_unique<ReportImpl>(exception))
|
|
{
|
|
}
|
|
|
|
Report::Report(const Message& message)
|
|
: mImpl(std::make_unique<ReportImpl>(message))
|
|
{
|
|
}
|
|
|
|
void Report::AddUserComment(const std::string& comment)
|
|
{
|
|
mImpl->AddUserComment(comment);
|
|
}
|
|
|
|
std::string Report::GetReportPreview() const
|
|
{
|
|
return mImpl->ToString(true);
|
|
}
|
|
|
|
void Report::Send(CompletionHandler completionHandler) const
|
|
{
|
|
mImpl->Send(std::move (completionHandler));
|
|
}
|
|
|
|
|
|
} // namespace sentry
|
|
} // namespace audacity
|