GEEKING

Android/libroblox/LogManager.cpp

@@ -0,0 +1,225 @@
+#include "LogManager.h"
+#include "RobloxUtilities.h"
+#include "JNIMain.h"
+
+#include <fstream>
+#include <utility>
+
+#include <boost/unordered_map.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread.hpp>
+#include <boost/algorithm/string/replace.hpp>
+
+#include "util/FileSystem.h"
+#include "util/Guid.h"
+#include "util/standardout.h"
+#include "util/RobloxGoogleAnalytics.h"
+#include "util/Http.h"
+#include "util/Statistics.h"
+#include "util/MemoryStats.h"
+#include "v8datamodel/Stats.h"
+
+#include "rbx/signal.h"
+
+#include "FastLog.h"
+#include "RbxAssert.h"
+
+#include <android/log.h>
+
+DYNAMIC_FASTINTVARIABLE(AndroidInfluxHundredthsPercentage, 0)
+
+
+// Traditional Android macros.
+#define LOG_TAG "roblox_jni"
+#define LOG_INFO(...)  __android_log_print(ANDROID_LOG_INFO,  LOG_TAG, __VA_ARGS__)
+#define LOG_WARNING(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+#define LOG_ERROR(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+#define CHANNEL_OUTPUT 1
+
+using namespace RBX;
+
+namespace RBX
+{
+namespace JNI
+{
+    extern std::string exceptionReasonFilename;  // set in JNIRobloxSettings.cpp
+    std::string platformUserAgent;               // set in JNIRobloxSettings.cpp
+    std::string robloxVersion;                   // set in JNIRobloxSettings.cpp
+    extern int lastPlaceId;                         // set in JNIGLActivity.cpp
+}
+}
+
+namespace
+{
+//static boost::shared_ptr<google_breakpad::ExceptionHandler> breakpadExceptionHandler;
+static bool cleanupCrashDumps;
+
+std::string getFastLogGuid()
+{
+    std::string logGuid;
+    RBX::Guid::generateStandardGUID(logGuid);
+    logGuid = logGuid.substr(1, 6);
+    return logGuid;
+}
+
+    static void ResponseFunc(std::string* response, std::exception* exception) { }
+
+
+
+static void standardOutCallback(const StandardOutMessage &msg)
+{
+    switch (msg.type)
+    {
+    case MESSAGE_OUTPUT:
+    case MESSAGE_INFO:
+        LOG_INFO("%s", msg.message.c_str());
+        break;
+    case MESSAGE_SENSITIVE:
+    case MESSAGE_WARNING:
+        LOG_WARNING("%s", msg.message.c_str());
+        break;
+    case MESSAGE_ERROR:
+        LOG_ERROR("%s", msg.message.c_str());
+        break;
+    default:
+        LOG_ERROR("Standard Message Out set with incorrect Message Type");
+        break;
+    }
+}
+
+static bool assertionHook(const char *expr, const char *filename, int lineNumber)
+{
+    StandardOut::singleton()->printf(MESSAGE_ERROR, "%s (%s:%d)", expr, filename, lineNumber);
+    return true; // allow assertion handler to perform rawBreak.
+}
+
+class LogManager
+{
+    typedef boost::unordered_map<FLog::Channel, boost::shared_ptr<std::ostream> > Channels;
+
+    boost::filesystem::path kLogPath;
+    std::string kLogGuid;
+    bool kInitialized;
+
+    Channels channels;
+    boost::mutex mutex;
+
+    rbx::signals::scoped_connection messageOutConnection;
+public:
+    LogManager() : kInitialized(false)
+    {
+        messageOutConnection = StandardOut::singleton()->messageOut.connect(&standardOutCallback);
+        StandardOut::singleton()->printf(MESSAGE_INFO, "StandardOut ready.");
+
+        setAssertionHook(&assertionHook);
+    }
+
+    ~LogManager()
+    {
+        boost::mutex::scoped_lock lock(mutex);
+        channels.clear(); // close all files and forget the file handles
+
+        messageOutConnection.disconnect();
+        LOG_INFO("StandardOut disconnected.");
+    }
+
+    void init(
+            const boost::filesystem::path &logPath,
+            const std::string &guid)
+    {
+        boost::mutex::scoped_lock lock(mutex);
+        kLogPath = logPath;
+        kLogGuid = guid;
+        kInitialized = true;
+    }
+
+    void writeEntry(const FLog::Channel &channelId, const char *message)
+    {
+        RBXASSERT(kInitialized);
+
+        boost::mutex::scoped_lock lock(mutex);
+
+        const Channels::iterator it = channels.find(channelId);
+        typename Channels::mapped_type stream;
+
+        if (channels.end() == it)
+        {
+            const int kLogChannel = channelId;
+
+            std::stringstream fileNameSS;
+            fileNameSS << "log_" << kLogGuid << "_" << kLogChannel << ".txt";
+            boost::filesystem::path path = kLogPath / fileNameSS.str();
+            StandardOut::singleton()->printf(MESSAGE_INFO, "Opening log file at %s", path.c_str());
+            typename Channels::value_type pair = std::make_pair(channelId, boost::shared_ptr<std::ostream>(new std::ofstream(path.c_str())));
+            if (!pair.second)
+            {
+                std::stringstream ss;
+                ss << "Could not open file: " << path.c_str();
+                throw RBX::runtime_error(ss.str().c_str());
+            }
+            else
+            {
+                channels.insert(pair);
+                stream = pair.second;
+            }
+        }
+        else
+        {
+            stream = it->second;
+        }
+
+        *stream << message << '\n';
+    }
+}; // LogManager
+
+static LogManager channels;
+
+static void fastLogMessageCallback(FLog::Channel channelId, const char* message)
+{
+    switch (channelId)
+    {
+    case CHANNEL_OUTPUT:
+        StandardOut::singleton()->printf(MESSAGE_INFO, "%s", message);
+        break;
+    default:
+        channels.writeEntry(channelId, message);
+        break;
+    }
+}
+} // namespace
+
+namespace RBX
+{
+namespace JNI
+{
+namespace LogManager
+{
+void setupFastLog()
+{
+    std::string logGuid = getFastLogGuid();
+    StandardOut::singleton()->printf(MESSAGE_INFO, "LogManager::kLogGuid = %s", logGuid.c_str());
+
+    std::string logPath = FileSystem::getCacheDirectory(true, "Log").string();
+    StandardOut::singleton()->printf(MESSAGE_INFO, "LogManager::kLogPath = %s", logPath.c_str());
+
+    channels.init(logPath, logGuid);
+
+    FLog::SetExternalLogFunc(&fastLogMessageCallback);
+    StandardOut::singleton()->printf(MESSAGE_INFO, "FastLog system ready.");
+}
+
+void tearDownFastLog()
+{
+    FLog::SetExternalLogFunc(NULL);
+    StandardOut::singleton()->printf(MESSAGE_INFO, "FastLog system offline.");
+}
+
+void setupBreakpad(bool cleanup)
+{
+    StandardOut::singleton()->printf(MESSAGE_INFO, "Initializing breakpad.");
+
+}
+} // namespace LogManager
+} // namespace JNI
+} // namespace RBX