Snoop.hh

Go to the documentation of this file.

 
/*
 
   Snoop
   Copyright (C) 2015-2024  Kasper Peeters
   Available under the terms of the GPL v3.
 
   Snoop is a lightweight logging library which stores its log entries in
    a local SQLite database or on a remote server.
 
 */
 
#pragma once
 
#ifndef __ANDROID__
   // Android uses Java/Kotlin networking, don't attempt to do it native.
   #define SNOOP_SSL
#endif
 
#include <string>
#include <sstream>
#include <sqlite3.h>
#include <stdint.h>
#include <mutex>
#include "nlohmann/json.hpp"
#include <thread>
#include <condition_variable>
#include <set>
 
#include "websocket_client.hh"
 
#ifndef _MSC_VER
  #include <unistd.h>
#endif
 
std::string safestring(const unsigned char *c);
 
namespace snoop {
 
    class SnoopImpl;
   class Flush {};
   extern Flush flush;
 
 
   class Snoop {
      public:
         Snoop();
         ~Snoop();
 
 
            void init(const std::string& app_name, const std::string& app_version, 
                      std::string server="", std::string local_log_file="", std::string machine_id="");
 
 
            std::string get_user_uuid(const std::string& app_name);
 
 
            Snoop& operator()(const std::string& type="", std::string fl="", int loc=-1, std::string method="");
       
 
         void set_local_type(const std::string& type);
 
 
            template<class T>
            Snoop& operator<<(const T& obj) {
               out_ <<(obj);
               return *this;
            }
 
 
            Snoop& payload(const std::vector<char>&);
            
 
         Snoop& operator<<(const Flush&);
 
 
            void set_sync_immediately(bool);
 
 
            void sync_with_server(bool from_wsthread=false);
            
 
            void sync_runs_with_server(bool from_wsthread=false);
            
 
            void sync_logs_with_server(bool from_wsthread=false);
            
 
            void sync_payloads_with_server(bool from_wsthread=false);
 
 
         bool is_connected() const;         
 
         
         std::string last_seen_version(std::string machine_id);
 
 
         bool authenticate(std::function<void (std::string, bool)>, std::string user="", std::string pass="", bool always_reauth=false);
 
            void set_error_handler(std::function<bool (std::string)>);
            
 
            class ParseError : public std::logic_error {
                public:
                    ParseError(const std::string&);
            };
            
 
            class Ticket {
                public:
                    Ticket();
                    int         ticket_id;
                    int         user_id;
                    std::string ticket_uuid;
                    bool        valid;
            };
         Ticket is_ticket_valid(std::string ticket_uuid);
 
 
            class AppEntry {
                public:
                    AppEntry();
                    AppEntry(const std::string& uuid_, uint64_t create_millis_, uint64_t receive_millis_, uint64_t pid_, 
                                const std::string& ip_address_, const std::string& machine_id_, 
                                const std::string& app_name_,   const std::string& app_version_,
                                const std::string& user_id_,
                                int server_status_, int create_timezone);
 
                    std::string to_json(bool human_readable) const;
                    void        from_json(const nlohmann::json&);
 
                    int         id;
                    std::string uuid;
                    uint64_t    create_millis;
                    uint64_t    receive_millis;
                    uint64_t    pid;
                    std::string ip_address;
                    std::string machine_id;
                    std::string app_name;
                    std::string app_version;
                    std::string user_id;
                    int         server_status; // 1: synced, 0 and negative: number of attempts at syncing made
                    bool        connected;
                    int         create_timezone;                    
            };
 
 
            class LogEntry {
                public:
                    LogEntry();
                    LogEntry(int log_id_, int client_log_id_, int id_, const std::string&, 
                                uint64_t, uint64_t, const std::string&, int, const std::string&, 
                                const std::string& , const std::string&, int status, const std::string&,
                                int create_timezone);
 
                    std::string to_json(bool human_readable) const;
                    void        from_json(const nlohmann::json&);
                    
                    int         log_id;
                    int         client_log_id;
                    int         id;
                    std::string uuid;              // this goes on the wire, but is not stored on disk.
                    uint64_t    create_millis;
                    uint64_t    receive_millis;
                    std::string loc_file;
                    int         loc_line;
                    std::string loc_method;
                    std::string type;
                    std::string message;
                    int         server_status;     // 1: synced, 0 and negative: number of attempts at syncing made
                    std::string session_uuid;
                    int         create_timezone;
            };
 
 
            class PayLoad {
                public:
                    PayLoad();
                    PayLoad(const std::vector<char>& data);
 
                    std::string to_json(bool human_readable) const;
                    void        from_json(const nlohmann::json&);
 
                    int         payload_id;
                    int         client_payload_id;
                    int         id;
                    std::string uuid;              // this goes on the wire, but is not stored on disk.
                    uint64_t    create_millis;
                    uint64_t    receive_millis;
                    std::string payload;
                    int         server_status;     // 1: synced, 0 and negative: number of attempts at syncing made
                    int         create_timezone;
            };
       
       
          std::string get_local_ticket();
 
 
            std::string local_user() const;
 
            
            void set_session_uuid(const std::string&);
            
 
         bool add_user(std::string user, std::string password, bool single=false);
 
      protected:
 
            void start_websocket_client();
 
 
            void create_tables();
 
 
          void create_authentication_tables();
 
 
            void obtain_uuid();
 
 
            bool store_app_entry(Snoop::AppEntry&);
            bool store_app_entry_without_lock(Snoop::AppEntry&);
 
 
            bool store_log_entry(Snoop::LogEntry&, bool avoid_server_duplicates);
 
 
            bool store_payload_entry(Snoop::PayLoad&);
 
            
            bool store_auth_attempt_entry(int user_id, int ticket_id, int valid, std::string msg);
            
 
            std::vector<Snoop::AppEntry> get_app_registrations(std::string uuid_filter="");
 
         
          int store_ticket(std::string ticket_uuid, int user_id, bool valid);
 
 
         void set_local_ticket(std::string ticket_uuid);
            
         
         bool          sync_immediately_;
          sqlite3      *db, *payload_db, *auth_db;
            sqlite3_stmt *insert_statement, *id_for_uuid_statement, *payload_insert_statement, *testq_statement;
            std::recursive_mutex    sqlite_mutex;
            
      private:
            
            websocket_client                wsclient;
            std::thread                     wsclient_thread;
            std::mutex                      connection_mutex;
            std::condition_variable         connection_cv;
            bool                            connection_is_open, connection_attempt_failed;
 
          // Main entry point for the I/O thread.
          void io_thread_run();
          void try_connect();
      
            void on_client_open();
            void on_client_fail(const boost::beast::error_code& ec);
            void on_client_close();
            void on_client_message(const std::string& msg);
 
            std::ostringstream out_;
            
            Snoop::AppEntry    this_app_;
            Snoop::LogEntry    this_log_;
            std::string        server_;
            std::string        session_uuid_; // gets copied into every LogEntry.
 
         std::recursive_mutex   call_mutex;
 
          std::set<std::string> local_types;
         std::function<void (std::string, bool)> authentication_callback;
            std::function<bool (std::string)>       error_callback;
 
   };
 
    extern Snoop log;
 
    const char info[] ="info";
    const char warn[] ="warning";
    const char error[]="error";
    const char fatal[]="fatal";
    const char email[]="email";
}
 
// set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__FILENAME__='\"$(subst
//  ${CMAKE_SOURCE_DIR}/,,$(abspath $<))\"'")
 
#define LOC __FILE__, __LINE__, __func__