ws: new command to subscribe to a cobra server and send an event to a sentry server

ws/IXSentryClient.cpp

@@ -0,0 +1,178 @@
+/*
+ *  IXSentryClient.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone. All rights reserved.
+ */
+
+#include "IXSentryClient.h"
+
+#include <chrono>
+#include <iostream>
+
+#include <ixwebsocket/IXWebSocketHttpHeaders.h>
+
+
+namespace ix
+{
+    SentryClient::SentryClient(const std::string& dsn) :
+        _dsn(dsn),
+        _validDsn(false),
+        _luaFrameRegex("\t([^/]+):([0-9]+): in function '([^/]+)'")
+    {
+        const std::regex dsnRegex("(http[s]?)://([^:]+):([^@]+)@([^/]+)/([0-9]+)");
+        std::smatch group;
+
+        if (std::regex_match(dsn, group, dsnRegex) and group.size() == 6)
+        {
+            _validDsn = true;
+
+            const auto scheme = group.str(1);
+            const auto host = group.str(4);
+            const auto project_id = group.str(5);
+            _url = scheme + "://" + host + "/api/" + project_id + "/store/";
+
+            _publicKey = group.str(2);
+            _secretKey = group.str(3);
+        }
+    }
+
+    int64_t SentryClient::getTimestamp()
+    {
+        const auto tp = std::chrono::system_clock::now();
+        const auto dur = tp.time_since_epoch();
+        return std::chrono::duration_cast<std::chrono::seconds>(dur).count();
+    }
+
+    std::string SentryClient::getIso8601()
+    {
+        std::time_t now;
+        std::time(&now);
+        char buf[sizeof "2011-10-08T07:07:09Z"];
+        std::strftime(buf, sizeof buf, "%Y-%m-%dT%H:%M:%SZ", std::gmtime(&now));
+        return buf;
+    }
+
+    std::string SentryClient::computeAuthHeader()
+    {
+        std::string securityHeader("Sentry sentry_version=5");
+        securityHeader += ",sentry_client=ws/1.0.0";
+        securityHeader += ",sentry_timestamp=" + std::to_string(SentryClient::getTimestamp());
+        securityHeader += ",sentry_key=" + _publicKey;
+        securityHeader += ",sentry_secret=" + _secretKey;
+
+        return securityHeader;
+    }
+
+    Json::Value SentryClient::parseLuaStackTrace(const std::string& stack)
+    {
+        Json::Value frames;
+
+        // Split by lines
+        std::string line;
+        std::stringstream tokenStream(stack);
+
+        std::stringstream ss;
+        std::smatch group;
+
+        while (std::getline(tokenStream, line))
+        {
+            //	MapScene.lua:2169: in function 'singleCB'
+            if (std::regex_match(line, group, _luaFrameRegex))
+            {
+                const auto fileName = group.str(1);
+                const auto linenoStr = group.str(2);
+                const auto function = group.str(3);
+
+                ss << linenoStr;
+                uint64_t lineno;
+                ss >> lineno;
+
+                Json::Value frame;
+                frame["lineno"] = lineno;
+                frame["filename"] = fileName;
+                frame["function"] = function;
+
+                frames.append(frame);
+            }
+        }
+
+        return frames;
+    }
+
+    std::string SentryClient::computePayload(const Json::Value& msg)
+    {
+        Json::Value payload;
+        payload["platform"] = "python";
+        payload["sdk"]["name"] = "ws";
+        payload["sdk"]["version"] = "1.0.0";
+        payload["timestamp"] = SentryClient::getIso8601();
+
+        Json::Value exception;
+        exception["value"] = msg["data"]["message"];
+
+        std::string stackTraceFieldName = 
+            (msg["id"].asString() == "game_noisytypes_id") ? "traceback" : "stack";
+                             
+        exception["stacktrace"]["frames"] = 
+            parseLuaStackTrace(msg["data"][stackTraceFieldName].asString());
+
+        payload["exception"].append(exception);
+
+        Json::Value extra;
+        extra["cobra_event"] = msg;
+
+        exception["extra"] = extra;
+
+        return _jsonWriter.write(payload);
+    }
+
+    bool SentryClient::send(const Json::Value& msg,
+                            bool verbose)
+    {
+        HttpRequestArgs args;
+        args.extraHeaders["X-Sentry-Auth"] = SentryClient::computeAuthHeader();
+        args.connectTimeout = 60;
+        args.transferTimeout = 5 * 60;
+        args.followRedirects = true;
+        args.verbose = verbose;
+        args.logger = [](const std::string& msg)
+        {
+            std::cout << msg;
+        };
+
+        std::string body = computePayload(msg);
+        HttpResponse out = _httpClient.post(_url, body, args);
+
+        auto statusCode = std::get<0>(out);
+        auto errorCode = std::get<1>(out);
+        auto responseHeaders = std::get<2>(out);
+        auto payload = std::get<3>(out);
+        auto errorMsg = std::get<4>(out);
+        auto uploadSize = std::get<5>(out);
+        auto downloadSize = std::get<6>(out);
+
+        if (verbose)
+        {
+            for (auto it : responseHeaders)
+            {
+                std::cerr << it.first << ": " << it.second << std::endl;
+            }
+
+            std::cerr << "Upload size: " << uploadSize << std::endl;
+            std::cerr << "Download size: " << downloadSize << std::endl;
+
+            std::cerr << "Status: " << statusCode << std::endl;
+            if (errorCode != HttpErrorCode_Ok)
+            {
+                std::cerr << "error message: " << errorMsg << std::endl;
+            }
+
+            if (responseHeaders["Content-Type"] != "application/octet-stream")
+            {
+                std::cerr << "payload: " << payload << std::endl;
+            }
+        }
+
+        return statusCode == 200;
+    }
+} // namespace ix