GEEKING

App/include/util/Analytics.h

@@ -0,0 +1,203 @@
+#pragma once
+
+#include <string>
+#include <sstream>
+#include <rapidjson/document.h>
+#include <boost/unordered_set.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include "FastLog.h"
+#include "RbxFormat.h"
+
+DYNAMIC_FASTFLAG(InfluxDb09Enabled)
+
+namespace RBX {
+
+namespace Analytics {
+
+	void setUserId(int id);
+	void setPlaceId(int id);
+	void setAppVersion(const std::string& version);
+	void setLocation(const std::string& loc);
+	void setReporter(const std::string& rep);
+
+namespace EphemeralCounter
+{
+	void reportStats(const std::string& category, float value, bool blocking = false);
+	void reportCountersCSV(const std::string& counterNamesCSV, bool blocking = false);
+	void reportCounter(const std::string& counterName, int amount, bool blocking = false);
+}
+
+namespace GoogleAnalytics
+{
+	// Allow for easy initialization based on a lottery number.
+	// Calls setCanUseAnalytics and init.
+	void lotteryInit(const std::string &accountPropertyID, int lotteryThreshold, const std::string& productName = "", int robloxAnalyticsLottery = -1, const std::string &sessionKey = "sessionID=");
+
+	// Must be called before using the singleton.
+	void init(const std::string &accountPropertyID, const std::string& productName = "");
+
+	bool getCanUse();
+	void setCanUse();
+
+	void sendEventRoblox(const char* category, const char* action = "custom", const char* label = "none", int value = 0, bool sync = false);
+
+	void trackEvent(const char *category, const char *action = "custom", const char *label = "none", int value = 0, bool sync = false);
+	void trackEventWithoutThrottling(const char *category, const char *action = "custom", const char *label = "none", int value = 0, bool sync = false);
+	void trackUserTiming(const char *category, const char *variable, int milliseconds, const char *label = "none", bool sync = false);
+
+	const std::string& getSessionId();
+
+} // namespace GoogleAnalytics
+
+
+namespace InfluxDb {
+
+	struct Point
+	{
+		std::string name;
+		std::string json;
+
+		Point(const std::string& name_, const rapidjson::Value& value) : name(name_)
+		{
+			using namespace rapidjson;
+
+			switch (value.GetType())
+			{
+			case kNullType:
+				json = "null";
+				break;
+			case kFalseType:
+				json = "false";
+				break;
+			case kTrueType:
+				json = "true";
+				break;
+			case kObjectType:
+			case kArrayType:
+				throw std::runtime_error("Arrays and objects are not valid value types.");
+				break;
+			case kStringType:
+                if (DFFlag::InfluxDb09Enabled)
+                {
+                    // we must escape double quotes
+                    std::string sval = value.GetString();
+                    boost::replace_all(sval, "\"", "\\\"");
+                    json = std::string("\"") + sval + "\"";
+                }
+                else
+                {
+                    json = std::string("\"") + value.GetString() + "\"";
+                }
+				break;
+			case kNumberType:
+				{
+					const rapidjson::Value& v = value;
+
+					std::stringstream ss;
+					if (v.IsDouble())
+					{
+						ss << v.GetDouble();
+					}
+					else if (v.IsInt())
+					{
+						ss << v.GetInt();
+                        if (DFFlag::InfluxDb09Enabled)
+                        {
+                            ss << 'i'; // signals integer type
+                        }
+					}
+					else if (v.IsInt64())
+					{
+						ss << v.GetInt64();
+                        if (DFFlag::InfluxDb09Enabled)
+                        {
+                            ss << 'i'; // signals integer type
+                        }
+					}
+					else if (v.IsUint())
+					{
+						ss << v.GetUint();
+                        if (DFFlag::InfluxDb09Enabled)
+                        {
+                            ss << 'i'; // signals integer type
+                        }
+					}
+					else if (v.IsUint64())
+					{
+						ss << v.GetUint64();
+                        if (DFFlag::InfluxDb09Enabled)
+                        {
+                            ss << 'i'; // signals integer type
+                        }
+					}
+					else
+					{
+						throw std::runtime_error("Unknown number type.");
+					}
+
+					ss >> json;
+				}
+				break;
+			default:
+				throw std::runtime_error("Unknown rapidjson value type.");
+				break;
+			}
+		}
+
+		bool operator==(const Point& other) const {
+			return this->name == other.name;
+		}
+	};
+	std::size_t hash_value(const Point& p);
+	
+	void init();
+	void reportPoints(const std::string& resource, const boost::unordered_set<Point>& points, int throttleHundredthsPercentage, bool blocking = false, const std::string& userIdOverride = "");
+	void reportPointsV2(const std::string& resource, const boost::unordered_set<Point>& points, int throttleHundredthsPercentage, bool blocking = false, const std::string& userIdOverride = "");
+
+	class Points
+	{
+		boost::unordered_set<Point> pointList;
+		std::string userIdOverride;
+
+	public:
+		Points() {}
+		~Points() {}
+
+		void setUserIdOverride(const int id)
+		{
+			userIdOverride = RBX::format("%d", id);
+		}
+
+		void addPoint(const std::string& name, const rapidjson::Value& value, bool override = false)
+		{
+			Point newPoint = Point(name, value);
+			std::pair<boost::unordered_set<Point>::iterator, bool> res = pointList.insert(newPoint);
+
+			if (override && !res.second)
+			{
+				pointList.erase(res.first);
+				pointList.insert(newPoint);
+			}
+		}
+
+		void report(const std::string& resource, int throttleHundredthsPercentage, bool blocking = false)
+		{
+			if (!pointList.empty())
+			{
+				if (DFFlag::InfluxDb09Enabled)
+					reportPointsV2(resource, pointList, throttleHundredthsPercentage, blocking, userIdOverride);
+				else
+					reportPoints(resource, pointList, throttleHundredthsPercentage, blocking, userIdOverride);
+				pointList.clear();
+			}
+		}
+
+		const boost::unordered_set<Point>& getPoints() { return pointList; }
+	};
+
+
+} // namespace InfluxDb
+
+} // namespace Analytics
+
+} // namespace RBX