SentryReport.cpp

Go to the documentation of this file.

/*!********************************************************************
 
 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
{
 
 
class ExceptionContext final
{
public:
   void Add(std::string parameterName, AnonymizedMessage parameterValue)
   {
      std::lock_guard<std::mutex> lock(mDataMutex);
      mData.emplace_back(std::move(parameterName), std::move(parameterValue));
   }
 
   std::vector<ExceptionData> MoveParameters()
   {
      std::lock_guard<std::mutex> lock(mDataMutex);
 
      std::vector<ExceptionData> emptyVector;
 
      std::swap(mData, emptyVector);
 
      return emptyVector;
   }
 
   static ExceptionContext& Get()
   {
      static ExceptionContext instance;
      return instance;
   }
 
private:
   ExceptionContext() = default;
 
   std::mutex mDataMutex;
   std::vector<ExceptionData> mData;
};
 
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);
}
 
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;
}
 
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);
}
 
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