[Sdk 911] Crash module added (#96)

* namespace added on countly classes

* request builder
request module

* request module completed
one deadlock remains

* request module integration completed
mutext shared ptr added

* code cleanup

* RQ Module added
Unit tests fixed

* crash module

* pr changes

* crash module integrated
unit tests added

* mutext added

* unit tests added

* Update CHANGELOG.md

* unit test comments added
sample app updated

Co-authored-by: ArtursKadikis <[email protected]>

Author: ZahidZafar

CHANGELOG.md

@@ -1,5 +1,7 @@
 22.06.1
 * !! Major breaking change !! We are removing the 'LogLevel' enum out of the 'Countly' class which will change how that enum can be referenced. 'Countly::LogLevel' will not work, you will have to use 'cly::LogLevel' instead.
+* Added functionality to record crash.
+* Added ability to record breadcrumbs for crash recording.
 
 22.06.0
 * !! Major breaking change !! We are adding the 'cly' namespace on 'Countly' class which will change how that class can be referenced. 'Countly::' will not work, you will have to use 'cly::Countly::' instead.

CMakeLists.txt

@@ -23,6 +23,9 @@ set(COUNTLY_PUBLIC_HEADERS
   ${CMAKE_CURRENT_SOURCE_DIR}/include/countly/constants.hpp
   ${CMAKE_CURRENT_SOURCE_DIR}/include/countly/event.hpp
   ${CMAKE_CURRENT_SOURCE_DIR}/include/countly/logger_module.hpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/countly/crash_module.hpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/countly/request_module.hpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/countly/request_builder.hpp
   ${CMAKE_CURRENT_SOURCE_DIR}/include/countly/views_module.hpp)
 
 add_library(countly
@@ -31,6 +34,7 @@ add_library(countly
   ${CMAKE_CURRENT_SOURCE_DIR}/src/views_module.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/logger_module.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/request_module.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/crash_module.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/request_builder.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/event.cpp)
 
@@ -85,6 +89,7 @@ if(COUNTLY_BUILD_TESTS)
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/views.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/session.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/event.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/crash.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/config.cpp)
 
     target_compile_definitions(countly-tests PRIVATE COUNTLY_BUILD_TESTS)

examples/example_integration.cpp

@@ -35,6 +35,7 @@ int main() {
   Countly &ct = Countly::getInstance();
   ct.alwaysUsePost(true);
   ct.setDeviceID("test-device-id");
+  // ct.setSalt("test-salt");
 
   ct.setLogger(printLog);
   // OS, OS_version, device, resolution, carrier, app_version);
@@ -44,6 +45,8 @@ int main() {
   ct.SetMaxEventsPerMessage(10);
   ct.setAutomaticSessionUpdateInterval(5);
 
+  ct.crash().addBreadcrumb("start");
+
   bool flag = true;
   while (flag) {
     cout << "Choose your option:" << endl;
@@ -58,6 +61,8 @@ int main() {
     cout << "9) Change device id without server merge" << endl;
     cout << "10) Set user location" << endl;
     cout << "11) Record a view" << endl;
+    cout << "12) Leave breadcrumb" << endl;
+    cout << "13) Record a crash with bread crumbs and segmentation" << endl;
     cout << "0) Exit" << endl;
     int a;
     cin >> a;
@@ -123,6 +128,24 @@ int main() {
       // Close an opened view
       ct.views().closeViewWithID(viewID);
     } break;
+    case 12: {
+      const std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+      const auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
+
+      ct.crash().addBreadcrumb(std::to_string(timestamp.count()));
+    } break;
+    case 13: {
+      std::map<std::string, std::string> segmentation = {
+          {"platform", "ubuntu"},
+          {"time", "60"},
+      };
+
+      std::map<std::string, std::string> crashMetrics = {
+          {"_run", "199222"}, {"_app_version", "1.0"}, {"_disk_current", "654321"}, {"_disk_total", "10585852"}, {"_os", "windows"},
+      };
+
+      ct.crash().recordException("Divided by zero", "stack trace", true, crashMetrics, segmentation);
+    } break;
     case 0:
       flag = false;
       break;

include/countly.hpp

@@ -25,6 +25,7 @@
 #include "countly/views_module.hpp"
 #include <countly/request_builder.hpp>
 #include <countly/request_module.hpp>
+#include <countly/crash_module.hpp>
 
 namespace cly {
 class Countly : public cly::CountlyDelegates {
@@ -141,6 +142,7 @@ class Countly : public cly::CountlyDelegates {
   void Stop() { stop(); }
 
   inline cly::ViewsModule &views() const { return *views_module.get(); }
+  inline cly::CrashModule &crash() const { return *crash_module.get(); }
 
   void RecordEvent(const std::string &key, int count) override { addEvent(cly::Event(key, count)); }
 
@@ -253,12 +255,13 @@ class Countly : public cly::CountlyDelegates {
   nlohmann::json session_params;
 
   std::unique_ptr<std::thread> thread;
+  std::unique_ptr<cly::CrashModule> crash_module;
   std::unique_ptr<cly::ViewsModule> views_module;
   std::shared_ptr<cly::CountlyConfiguration> configuration;
   std::shared_ptr<cly::LoggerModule> logger;
 
   std::shared_ptr<cly::RequestBuilder> requestBuilder;
-  std::unique_ptr<cly::RequestModule> requestModule;
+  std::shared_ptr<cly::RequestModule> requestModule;
   std::shared_ptr<std::mutex> mutex = std::make_shared<std::mutex>();
 
   bool is_queue_being_processed = false;

include/countly/crash_module.hpp

@@ -0,0 +1,42 @@
+#ifndef CRASH_MODULE_HPP_
+#define CRASH_MODULE_HPP_
+#include <map>
+#include <memory>
+#include <string>
+
+#include "countly/constants.hpp"
+#include "countly/countly_configuration.hpp"
+#include "countly/logger_module.hpp"
+#include "countly/request_module.hpp"
+
+namespace cly {
+class CrashModule {
+
+public:
+  ~CrashModule();
+  CrashModule(std::shared_ptr<CountlyConfiguration> config, std::shared_ptr<LoggerModule> logger, std::shared_ptr<RequestModule> requestModule, std::shared_ptr<std::mutex> mutex);
+  /**
+   * Adds string value to a list which is later sent over as logs whenever a cash is reported by system.
+   *
+   * @param value: a bread crumb for the crash report
+   */
+  void addBreadcrumb(const std::string &value);
+
+  /**
+   * Public method that sends crash details to the server. Set param "fatal" to false for Custom Logged errors
+
+   * @param title: a string that contains description of the exception.
+   * @param stackTrace: a string that describes the contents of the call-stack.
+   * @param segmentation: custom key/values to be reported
+   * @param crashMetrics: contains device information e.g app version, OS.
+   * In crash metrics '_os', '_app_version' and '_error' are mandatory.
+   * @param fatal: For automatically captured errors, you should set to 'true', whereas on logged errors it should be 'false'.
+   */
+  void recordException(const std::string &title, const std::string &stackTrace, const bool fatal, const std::map<std::string, std::string> &crashMetrics, const std::map<std::string, std::string> &segmentation = {});
+
+private:
+  class CrashModuleImpl;
+  std::unique_ptr<CrashModuleImpl> impl;
+};
+} // namespace cly
+#endif

src/countly.cpp

@@ -18,6 +18,7 @@
 
 namespace cly {
 Countly::Countly() {
+  crash_module = nullptr;
   views_module = nullptr;
   logger.reset(new cly::LoggerModule());
   configuration.reset(new cly::CountlyConfiguration("", ""));
@@ -30,6 +31,7 @@ Countly::Countly() {
 Countly::~Countly() {
   is_being_disposed = true;
   stop();
+  crash_module.reset();
   views_module.reset();
   logger.reset();
 
@@ -307,6 +309,7 @@ void Countly::start(const std::string &app_key, const std::string &host, int por
 
   requestBuilder.reset(new RequestBuilder(configuration, logger));
   requestModule.reset(new RequestModule(configuration, logger, requestBuilder));
+  crash_module.reset(new cly::CrashModule(configuration, logger, requestModule, mutex));
   views_module.reset(new cly::ViewsModule(this, logger));
 
   is_sdk_initialized = true; // after this point SDK is initialized.

src/crash_module.cpp

@@ -0,0 +1,82 @@
+#include "countly/crash_module.hpp"
+#include "countly/request_module.hpp"
+
+#include <algorithm>
+#include <deque>
+#include <iostream>
+#include <iterator>
+
+namespace cly {
+class CrashModule::CrashModuleImpl {
+public:
+  std::deque<std::string> _breadCrumbs;
+  std::shared_ptr<CountlyConfiguration> _configuration;
+  std::shared_ptr<LoggerModule> _logger;
+  std::shared_ptr<RequestModule> _requestModule;
+  std::shared_ptr<std::mutex> _mutex;
+  CrashModuleImpl(std::shared_ptr<CountlyConfiguration> config, std::shared_ptr<LoggerModule> logger, std::shared_ptr<RequestModule> requestModule, std::shared_ptr<std::mutex> mutex) : _configuration(config), _logger(logger), _requestModule(requestModule), _mutex(mutex) {}
+
+  ~CrashModuleImpl() { _logger.reset(); }
+};
+
+CrashModule::~CrashModule() { impl.reset(); }
+
+CrashModule::CrashModule(std::shared_ptr<CountlyConfiguration> config, std::shared_ptr<LoggerModule> logger, std::shared_ptr<RequestModule> requestModule, std::shared_ptr<std::mutex> mutex) {
+  impl.reset(new CrashModuleImpl(config, logger, requestModule, mutex));
+
+  impl->_logger->log(LogLevel::DEBUG, cly::utils::format_string("[CrashModule] Initialized"));
+}
+
+void CrashModule::addBreadcrumb(const std::string &value) {
+  impl->_logger->log(LogLevel::INFO, "[CrashModule] addBreadcrumb : " + value);
+
+  impl->_mutex->lock();
+  if (impl->_breadCrumbs.size() >= impl->_configuration->breadcrumbsThreshold) {
+    impl->_breadCrumbs.pop_front();
+  }
+
+  impl->_breadCrumbs.push_back(value);
+  impl->_mutex->unlock();
+}
+
+void CrashModule::recordException(const std::string &title, const std::string &stackTrace, const bool fatal, const std::map<std::string, std::string> &crashMetrics, const std::map<std::string, std::string> &segmentation) {
+
+  impl->_logger->log(LogLevel::INFO, cly::utils::format_string("[CrashModule] recordException: title = %s, stackTrace = %s", title.c_str(), stackTrace.c_str()));
+
+  if (title.empty()) {
+    impl->_logger->log(LogLevel::WARNING, "[CrashModule] recordException : The parameter 'title' can't be empty");
+  }
+
+  if (stackTrace.empty()) {
+    impl->_logger->log(LogLevel::ERROR, "[CrashModule] recordException : The parameter 'stackTrace' can't be empty");
+  }
+
+  auto it = crashMetrics.find("_os");
+  if (it == crashMetrics.end() || it->second.empty()) {
+    impl->_logger->log(LogLevel::ERROR, "[CrashModule] recordException : The crash metric '_os' can't be empty");
+  }
+
+  it = crashMetrics.find("_app_version");
+  if (it == crashMetrics.end() || it->second.empty()) {
+    impl->_logger->log(LogLevel::ERROR, "[CrashModule] recordException : The crash metric '_app_version' can't be empty");
+  }
+
+  impl->_mutex->lock();
+  std::ostringstream outstream;
+  std::copy(impl->_breadCrumbs.begin(), impl->_breadCrumbs.end(), std::ostream_iterator<std::string>(outstream, "\n"));
+
+  nlohmann::json crash(crashMetrics);
+  nlohmann::json segments(segmentation);
+
+  crash["_name"] = title;
+  crash["_error"] = stackTrace;
+  crash["_logs"] = outstream.str();
+  crash["_custom"] = segments;
+  crash["_nonfatal"] = !fatal;
+
+  std::map<std::string, std::string> data = {{"crash", crash.dump()}};
+  impl->_requestModule->addRequestToQueue(data);
+  impl->_mutex->unlock();
+}
+
+} // namespace cly

src/request_builder.cpp

@@ -26,9 +26,7 @@ std::string RequestBuilder::buildRequest(const std::map<std::string, std::string
   const std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
   const auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
 
-  std::map<std::string, std::string> request = {{"app_key", _configuration->appKey},
-                                                //  {"device_id", _configuration->deviceId},
-                                                {"timestamp", std::to_string(timestamp.count())}};
+  std::map<std::string, std::string> request = {{"app_key", _configuration->appKey}, {"device_id", _configuration->deviceId}, {"timestamp", std::to_string(timestamp.count())}};
 
   request.insert(data.begin(), data.end());
   return serializeData(request);
@@ -42,8 +40,10 @@ std::string RequestBuilder::serializeData(const std::map<std::string, std::strin
   }
 
   std::string serialized_string = serialized.str();
-  serialized_string.resize(serialized_string.size() - 1);
-
+  if (serialized_string.size() > 0 ) {
+    serialized_string.resize(serialized_string.size() - 1);
+  }
+  
   return serialized_string;
 }
 } // namespace cly

src/views_module.cpp

@@ -91,9 +91,9 @@ class ViewsModule::ViewModuleImpl {
   void _closeViewWithName(const std::string &name) {
     std::shared_ptr<ViewModuleImpl::ViewInfo> v = findViewByName(name);
     if (v == nullptr) {
-      cly::LogLevel::WARNING, cly::utils::format_string("[ViewModuleImpl] _closeViewWithName:  Couldn't found "
+      _logger->log(cly::LogLevel::WARNING, cly::utils::format_string("[ViewModuleImpl] _closeViewWithName:  Couldn't found "
                                                         "view with name = %s",
-                                                        name.c_str());
+                                                        name.c_str()));
       return;
     }
     _recordView(v, {}, false);
@@ -102,9 +102,9 @@ class ViewsModule::ViewModuleImpl {
   void _closeViewWithID(const std::string &viewId) {
 
     if (_viewsStartTime.find(viewId) == _viewsStartTime.end()) {
-      cly::LogLevel::WARNING, cly::utils::format_string("[ViewModuleImpl] _closeViewWithID:  Couldn't found "
+      _logger->log(cly::LogLevel::WARNING, cly::utils::format_string("[ViewModuleImpl] _closeViewWithID:  Couldn't found "
                                                         "view with viewId = %s",
-                                                        viewId.c_str());
+                                                        viewId.c_str()));
       return;
     }
 

tests/config.cpp

@@ -2,6 +2,7 @@
 #include "doctest.h"
 #include "test_utils.hpp"
 using namespace cly;
+using namespace test_utils;
 
 std::string customSha256(const std::string &data) { return "SHA256"; }