- gitignore update

- session update interval issue fixed
- event duration constructor and public function added
- sample app added

Author: ZahidZafar

.gitignore

@@ -1,5 +1,8 @@
 # for out of source builds
 build/
+.idea/
+.vscode/
+.project
 
 # cmake generates these files
 src/countly.hpp

CMakeLists.txt

@@ -10,6 +10,7 @@ option(BUILD_SHARED_LIBS "Build shared libraries" ON)
 option(COUNTLY_USE_CUSTOM_HTTP "Use a custom HTTP library" OFF)
 option(COUNTLY_USE_SQLITE "Use SQLite" OFF)
 option(COUNTLY_BUILD_TESTS "Build test programs" OFF)
+option(COUNTLY_BUILD_SAMPLE "Build Sample programs" OFF)
 
 if (NOT WIN32 AND NOT BUILD_SHARED_LIBS AND NOT COUNTLY_CUSTOM_HTTP)
   message(FATAL_ERROR "You must provide a custom HTTP function when compiling statically.")
@@ -72,3 +73,19 @@ if(COUNTLY_BUILD_TESTS)
     CXX_STANDARD_REQUIRED YES
     CXX_EXTENSIONS NO)
 endif()
+
+if(COUNTLY_BUILD_SAMPLE)
+  add_executable(countly-sample
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/example_integration.cpp)
+  if(COUNTLY_USE_SQLITE)
+    target_compile_definitions(countly-tests PRIVATE COUNTLY_USE_SQLITE)
+    target_include_directories(countly-tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/vendor/sqlite)
+  endif()
+  target_include_directories(countly-sample PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/vendor/doctest/doctest)
+  target_include_directories(countly-sample PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/vendor/json/include)
+  target_link_libraries(countly-sample countly)
+  set_target_properties(countly-sample PROPERTIES
+    CXX_STANDARD 11
+    CXX_STANDARD_REQUIRED YES
+    CXX_EXTENSIONS NO)
+endif()

examples/example_integration.cpp

@@ -0,0 +1,105 @@
+#include <thread>
+#include <chrono>
+#include <random>
+#include <iostream>
+using namespace std;
+
+
+#include "countly.hpp"
+
+void printLog(Countly::LogLevel level, const string& msg) {
+	string lvl = "[DEBUG]";
+	switch (level)
+	{
+	case Countly::LogLevel::DEBUG/* constant-expression */:
+		/* code */
+		lvl = "[Debug]";
+		break;
+	case Countly::LogLevel::INFO/* constant-expression */:
+		/* code */
+		lvl = "[INFO]";
+		break;
+		case Countly::LogLevel::WARNING/* constant-expression */:
+		/* code */
+		lvl = "[WARNING]";
+		break;
+		case Countly::LogLevel::ERROR/* constant-expression */:
+		/* code */
+		lvl = "[ERROR]";
+		break;
+		case Countly::LogLevel::FATAL/* constant-expression */:
+		/* code */
+		lvl = "[FATAL]";
+		break;
+	
+	default:
+		break;
+	}
+	
+	cout<<lvl<<msg<<endl;
+}
+
+
+
+int main() {
+	cout<<"Sample App"<<endl;
+	Countly& ct = Countly::getInstance();
+	ct.alwaysUsePost(true);
+	ct.setDeviceID("zahidzafar");
+
+	void (*logger_function)(Countly::LogLevel level, const std::string& message);
+	logger_function = printLog;
+	ct.setLogger(logger_function);
+	// OS, OS_version, device, resolution, carrier, app_version);
+	ct.SetMetrics("Windows 10", "10.22", "Mac", "800x600", "Carrier", "1.0");
+	ct.setCustomUserDetails({{"Account Type", "Basic"}, {"Employer", "Company4"}});
+	// Server and port
+	ct.Start("8c1d653f8f474be24958b282d5e9b4c4209ee552", "https://master.count.ly", 443);
+	ct.SetMaxEventsPerMessage(10);
+	ct.SetMinUpdatePeriod(10);
+	ct.setUpdateInterval(15);
+
+	bool flag = true;
+	while (flag)
+	{
+		cout<<"Choose your option:"<<endl;
+		cout<<"1) Basic Event"<<endl;
+		cout<<"2) Event with count and sum"<<endl;
+		cout<<"3) Event with count, sum, duration"<<endl;
+		cout<<"4) Event with sum, count, duration and segmentation"<<endl;
+		cout<<"0) Exit"<<endl;
+		int a;
+		cin>>a;
+		switch (a)
+		{
+		case 1:
+			ct.RecordEvent("Basic Event", 123);
+			break;
+		case 2:
+			ct.RecordEvent("Event with count and sum", 644, 13.3);
+			break;
+		case 3: {
+			Countly::Event event("Event with sum, count, duration", 1, 10, 60.5);
+			ct.addEvent(event);
+			break;
+		}
+		case 4: {
+			std::map<std::string, std::string> segmentation;
+			segmentation["height"] = "5.10";
+			ct.RecordEvent("Event with sum, count, duration and segmentation", segmentation, 1, 0, 10);
+			break;
+		}
+		case 0:
+			flag = false;
+			break;
+		
+		default:
+			cout<<"Option not found!"<<endl;
+			break;
+		}
+	}
+
+	ct.updateSession();
+
+	return 0;
+}

examples/using_thread.cpp

@@ -115,6 +115,7 @@ class Countly {
 	public:
 		Event(const std::string& key, size_t count = 1);
 		Event(const std::string& key, size_t count, double sum);
+		Event(const std::string& key, size_t count, double sum, double duration);
 
 		void setTimestamp();
 
@@ -196,6 +197,16 @@ class Countly {
 
 		addEvent(event);
 	}
+
+	void RecordEvent(const std::string key, std::map<std::string, std::string> segmentation, int count, double sum, double duration) {
+		Event event(key, count, sum, duration);
+
+		for (auto key_value: segmentation) {
+			event.addSegmentation(key_value.first, json::parse(key_value.second));
+		}
+
+		addEvent(event);
+	}
 private:
 	void log(LogLevel level, const std::string& message);
 

include/countly.hpp

@@ -182,6 +182,7 @@ void Countly::setDeviceID(const std::string& value, bool same_user) {
 
 void Countly::start(const std::string& app_key, const std::string& host, int port, bool start_thread) {
 	mutex.lock();
+	log(Countly::LogLevel::DEBUG, "[Countly][start]");
 	this->host = host;
 	if (host.find("http://") == 0) {
 		use_https = false;
@@ -369,6 +370,7 @@ void Countly::flushEvents(std::chrono::seconds timeout) {
 
 bool Countly::beginSession() {
 	mutex.lock();
+	log(Countly::LogLevel::DEBUG, "[Countly] [beginSession]");
 	if (began_session) {
 		mutex.unlock();
 		return true;
@@ -408,6 +410,8 @@ bool Countly::beginSession() {
 }
 
 bool Countly::updateSession() {
+	log(Countly::LogLevel::DEBUG, "Countly::updateSession");
+
 	mutex.lock();
 	if (!began_session) {
 		mutex.unlock();
@@ -486,7 +490,7 @@ bool Countly::updateSession() {
 				mutex.unlock();
 				return false;
 			}
-			last_sent += duration;
+			last_sent = Countly::getTimestamp();
 		}
 
 		mutex.unlock();
@@ -530,6 +534,7 @@ bool Countly::updateSession() {
 }
 
 bool Countly::endSession() {
+	log(Countly::LogLevel::DEBUG, "[Countly] [endSession]");
 	const std::chrono::system_clock::time_point now = Countly::getTimestamp();
 	const auto timestamp = std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch());
 	const auto duration = std::chrono::duration_cast<std::chrono::seconds>(getSessionDuration(now));
@@ -626,6 +631,7 @@ static size_t countly_curl_write_callback(void *data, size_t byte_size, size_t n
 Countly::HTTPResponse Countly::sendHTTP(std::string path, std::string data) {
 	bool use_post = always_use_post || (data.size() > COUNTLY_POST_THRESHOLD);
 
+log(Countly::LogLevel::INFO, "[Countly] [sendHTTP] data: "+ data);
 	if (!salt.empty()) {
 		unsigned char checksum[SHA256_DIGEST_LENGTH];
 		std::string salted_data = data + salt;
@@ -762,6 +768,8 @@ Countly::HTTPResponse Countly::sendHTTP(std::string path, std::string data) {
 			curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data.c_str());
 		}
 
+		log(Countly::LogLevel::INFO, "[Countly][sendHTTP] request: " + full_url_stream.str());
+
 		std::string full_url = full_url_stream.str();
 		curl_easy_setopt(curl, CURLOPT_URL, full_url.c_str());
 
@@ -771,24 +779,26 @@ Countly::HTTPResponse Countly::sendHTTP(std::string path, std::string data) {
 
 		curl_code = curl_easy_perform(curl);
 		if (curl_code == CURLE_OK) {
+
 			long status_code;
 			curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status_code);
 			response.success = (status_code >= 200 && status_code < 300);
 			if (!body.empty()) {
 				response.data = json::parse(body);
 			}
 		}
-
 		curl_easy_cleanup(curl);
 	}
 #endif
+	log(Countly::LogLevel::INFO, "[Countly][sendHTTP] response: " + response.data.dump());
 	return response;
 #endif
+
 }
 
 std::chrono::system_clock::duration Countly::getSessionDuration(std::chrono::system_clock::time_point now) {
 	mutex.lock();
-	std::chrono::system_clock::duration duration = last_sent - now;
+	std::chrono::system_clock::duration duration = now - last_sent;
 	mutex.unlock();
 	return duration;
 }
@@ -798,6 +808,7 @@ std::chrono::system_clock::duration Countly::getSessionDuration() {
 }
 
 void Countly::updateLoop() {
+	log(Countly::LogLevel::INFO, "[Countly][updateLoop]");
 	mutex.lock();
 	running = true;
 	mutex.unlock();

src/countly.cpp

@@ -11,6 +11,13 @@ Countly::Event::Event(const std::string& key, size_t count, double sum) : object
 	object["sum"] = sum;
 }
 
+Countly::Event::Event(const std::string& key, size_t count, double sum, double duration) : object({}), timer_running(false) {
+	object["key"] = key;
+	object["count"] = count;
+	object["sum"] = sum;
+	object["dur"] = duration;
+}
+
 void Countly::Event::setTimestamp() {
 	timestamp = Countly::getTimestamp();
 	object["timestamp"] = std::chrono::duration_cast<std::chrono::seconds>(timestamp.time_since_epoch()).count();

src/event.cpp

@@ -53,6 +53,12 @@ TEST_CASE("events are serialized correctly") {
 			CHECK(event.serialize() == "{\"count\":3,\"key\":\"lose\",\"segmentation\":{\"points\":2000}}");
 		}
 
+		SUBCASE("with count, sum, duration and segmentation") {
+			Countly::Event event("lose", 3, 10, 100);
+			event.addSegmentation("points", 2000);
+			CHECK(event.serialize() == "{\"count\":3,\"dur\":100.0,\"key\":\"lose\",\"segmentation\":{\"points\":2000},\"sum\":10.0}");
+		}
+
 		SUBCASE("with multibyte strings") {
 			Countly::Event event("测试", 1);
 			event.addSegmentation("苹果", "美味");

tests/event.cpp

@@ -198,6 +198,21 @@ TEST_CASE("events are sent correctly") {
 		CHECK(http_call.data["events"] == "[{\"count\":2,\"key\":\"win\"},{\"count\":1,\"key\":\"achievement\"}]");
 	}
 
+	SUBCASE("event with count, sum, duration and segmentation is sent") {
+		Countly::Event event("lose", 3, 10, 100);
+		event.addSegmentation("points", 2000);
+		countly.addEvent(event);
+
+		WAIT_FOR_SQLITE(1);
+		countly.updateSession();
+			
+		HTTPCall http_call = popHTTPCall();
+		CHECK(!http_call.use_post);
+		CHECK(http_call.data["app_key"] == COUNTLY_TEST_APP_KEY);
+		CHECK(http_call.data["device_id"] == COUNTLY_TEST_DEVICE_ID);
+		CHECK(http_call.data["events"] == "[{\"count\":3,\"dur\":100.0,\"key\":\"lose\",\"segmentation\":{\"points\":2000},\"sum\":10.0}]");
+	}
+
 	SUBCASE("100 events are sent") {
 		for (int i = 0; i < 100; i++) {
 			Countly::Event event("click", i);