[Sdk 884] Logger module added (#64)

* Logger module completed

* Countly::log method added back

* signature udpated

* Method documentation added
Unit tests added

* MISRA  rule: 14.4 appled

* Update countly.cpp

* Update countly.hpp

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

Author: ZahidZafar

CMakeLists.txt

@@ -20,6 +20,7 @@ endif()
 
 add_library(countly
   ${CMAKE_CURRENT_SOURCE_DIR}/src/countly.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/logger_module.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/event.cpp)
 
 target_include_directories(countly

examples/example_integration.cpp

@@ -40,9 +40,7 @@ int main() {
 	ct.alwaysUsePost(true);
 	ct.setDeviceID("test-device-id");
 
-	Countly::LoggerFunction logger_function;
-	logger_function = printLog;
-	ct.setLogger(logger_function);
+	ct.setLogger(printLog);
 	// OS, OS_version, device, resolution, carrier, app_version);
 	ct.SetMetrics("Windows 10", "10.22", "Mac", "800x600", "Carrier", "1.0");
 	// Server and port

include/countly.hpp

@@ -22,8 +22,7 @@ using json = nlohmann::json;
 #ifdef _WIN32
 #undef ERROR
 #endif
-
-using namespace::countly_sdk;
+#include "countly/logger_module.hpp"
 
 class Countly {
 public:
@@ -43,17 +42,22 @@ class Countly {
 
 	void setSalt(const std::string& value);
 
-	enum LogLevel {DEBUG, INFO, WARNING, ERROR, FATAL};
+	enum LogLevel { DEBUG = 1, INFO = 2, WARNING = 3, ERROR = 4, FATAL = 5 };
 
-	using LoggerFunction = std::function<void(LogLevel, const std::string&)>;
-	void setLogger(LoggerFunction fun);
+	void setLogger(void (*fun)(LogLevel level, const std::string& message));
+	
+	/*
+	This function should not be used as it will be removed in a future release. It is
+	currently added as a temporary workaround.
+	*/
+	inline std::function<void(LogLevel, const std::string&)> getLogger() { return logger_function; }
 
 	struct HTTPResponse {
 		bool success;
 		json data;
 	};
 
-	void setSha256(SHA256Function fun);
+	void setSha256(cly::SHA256Function fun);
 
 	using HTTPClientFunction = std::function<HTTPResponse(bool, const std::string&, const std::string&)>;
 	void setHTTPClient(HTTPClientFunction fun);
@@ -252,9 +256,9 @@ class Countly {
 
 	void updateLoop();
 
-	SHA256Function sha256_function;
-	LoggerFunction logger_function;
+	cly::SHA256Function sha256_function;
 	HTTPClientFunction http_client_function;
+	void (*logger_function)(LogLevel level, const std::string& message) = nullptr;
 
 	std::string host;
 
@@ -272,6 +276,8 @@ class Countly {
 	std::string salt;
 
 	std::unique_ptr<std::thread> thread;
+	std::unique_ptr<cly::LoggerModule> logger;
+
 	std::mutex mutex;
 	bool stop_thread = false;
 	bool running = false;

include/countly/constants.hpp

@@ -11,7 +11,7 @@
 #define COUNTLY_KEEPALIVE_INTERVAL 3000
 #define COUNTLY_MAX_EVENTS_DEFAULT 200
 
-namespace countly_sdk {
+namespace cly {
 	using SHA256Function = std::function<std::string(const std::string&)>;
 }
 

include/countly/logger_module.hpp

@@ -0,0 +1,39 @@
+#ifndef LOGGER_MODULE_HPP_
+#define LOGGER_MODULE_HPP_
+#include <string>
+#include <memory>
+#include <functional>
+
+namespace cly {
+	enum class LogLevel { DEBUG = 1, INFO = 2, WARNING = 3, ERROR = 4, FATAL = 5 };
+	using LoggerFunction = std::function<void(LogLevel, const std::string&)>;
+
+	class LoggerModule {
+	public:
+		LoggerModule();
+		~LoggerModule();
+
+		/**
+		* Set custom logger function.
+		*
+		* @param logger pointer to function.
+		*/
+		void setLogger(LoggerFunction logger);
+
+		/**
+		* Print important information.
+		*
+		* @param level importance and urgency of the message.
+		* @param message description of log.
+		*/
+		void log(LogLevel level, const std::string& message);
+
+	private:
+		class LoggerModuleImpl;
+		std::unique_ptr<LoggerModuleImpl> impl;
+	};
+
+
+}
+#endif
+

src/countly.cpp

@@ -31,6 +31,8 @@ using json = nlohmann::json;
 #endif
 
 Countly::Countly() {
+	logger.reset(new cly::LoggerModule());
+
 #if !defined(_WIN32) && !defined(COUNTLY_USE_CUSTOM_HTTP)
 	curl_global_init(CURL_GLOBAL_ALL);
 #endif
@@ -39,6 +41,8 @@ Countly::Countly() {
 Countly::~Countly() {
 	is_being_disposed = true;
 	stop();
+	logger.reset();
+
 #if !defined(_WIN32) && !defined(COUNTLY_USE_CUSTOM_HTTP)
 	curl_global_cleanup();
 #endif
@@ -61,9 +65,21 @@ void Countly::setSalt(const std::string& value) {
 	mutex.unlock();
 }
 
-void Countly::setLogger(LoggerFunction fun) {
+void temp_log(cly::LogLevel level, const std::string& msg) {
+	Countly::getInstance().getLogger()(Countly::LogLevel(level), msg);
+}
+
+void Countly::setLogger(void (*fun)(Countly::LogLevel level, const std::string& message)) {
 	mutex.lock();
+
 	logger_function = fun;
+	if (fun == nullptr) {
+		logger->setLogger(nullptr);
+	}
+	else {
+		logger->setLogger(temp_log);
+	}
+	
 	mutex.unlock();
 }
 
@@ -73,7 +89,7 @@ void Countly::setHTTPClient(HTTPClientFunction fun) {
 	mutex.unlock();
 }
 
-void Countly::setSha256(SHA256Function fun) {
+void Countly::setSha256(cly::SHA256Function fun) {
 	mutex.lock();
 	sha256_function = fun;
 	mutex.unlock();
@@ -788,10 +804,8 @@ void Countly::setDatabasePath(const std::string& path) {
 }
 #endif
 
-void Countly::log(Countly::LogLevel level, const std::string& message) {
-	if (logger_function) {
-		logger_function(level, message);
-	}
+void Countly::log(LogLevel level, const std::string& message) {
+	logger->log(cly::LogLevel(level), message);
 }
 
 static size_t countly_curl_write_callback(void *data, size_t byte_size, size_t n_bytes, std::string *body) {
@@ -804,7 +818,7 @@ std::string Countly::calculateChecksum(const std::string& salt, const std::strin
 	std::string salted_data = data + salt;
 #ifdef COUNTLY_USE_CUSTOM_SHA256
 	if (sha256_function == nullptr) {
-		log(Countly::LogLevel::FATAL, "Missing SHA 256 function");
+		log(LogLevel::FATAL, "Missing SHA 256 function");
 		return {};
 	}
 

src/logger_module.cpp

@@ -0,0 +1,28 @@
+#include "countly/logger_module.hpp"
+#include <iostream>
+namespace cly {
+	class LoggerModule::LoggerModuleImpl {
+	public:
+		LoggerFunction logger_function;
+
+	};
+
+	LoggerModule::LoggerModule()
+	{
+		impl.reset(new LoggerModuleImpl());
+	}
+
+	LoggerModule::~LoggerModule() {
+	}
+
+	void LoggerModule::setLogger(LoggerFunction logger) {
+		impl->logger_function = logger;
+	}
+
+	void LoggerModule::log(LogLevel level, const std::string& message) {
+		if (impl->logger_function != nullptr) {
+			impl->logger_function(level, message);
+		}
+	}
+}
+

tests/main.cpp

@@ -135,6 +135,24 @@ std::string customChecksumCalculator(const std::string& data) {
 	return result;
 }
 
+void printLog(Countly::LogLevel level, const std::string& msg) {
+	CHECK(msg == "message");
+	CHECK(level == Countly::LogLevel::DEBUG);
+}
+
+TEST_CASE("Logger function validation") {
+	Countly& countly = Countly::getInstance();
+
+	CHECK(countly.getLogger() == nullptr);
+	countly.setLogger(printLog);
+	CHECK(countly.getLogger() != nullptr);
+	
+	countly.getLogger()(Countly::LogLevel::DEBUG, "message");
+
+	countly.setLogger(nullptr);
+	CHECK(countly.getLogger() == nullptr);
+}
+
 TEST_CASE("custom sha256 function validation") {
 	Countly& countly = Countly::getInstance();