Snoop.hh

Go to the documentation of this file.

 
/*
 
   Snoop
   Copyright (C) 2015-2020  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
 
#include <string>
#include <sstream>
#include <sqlite3.h>
#include <stdint.h>
#include <mutex>
#include "nlohmann/json.hpp"
#include <thread>
#include <set>
#ifdef SNOOP_SSL
  #include <websocketpp/config/asio_client.hpp>
#else
  #include <websocketpp/config/asio_no_tls_client.hpp>
#endif
#include <websocketpp/client.hpp>
#include <websocketpp/common/thread.hpp>
#include <websocketpp/common/functional.hpp>
 
#ifndef _MSC_VER
  #include <unistd.h>
#endif
 
#ifdef SNOOP_SSL
   typedef websocketpp::client<websocketpp::config::asio_tls_client> WebsocketClient;
#else
   typedef websocketpp::client<websocketpp::config::asio_client> WebsocketClient;
#endif
typedef websocketpp::config::asio_client::message_type::ptr   message_ptr;
 
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="");
       
 
            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();
       
 
      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;
            std::recursive_mutex    sqlite_mutex;
 
      private:
            
            WebsocketClient                 wsclient;
            std::thread                     wsclient_thread;
            std::mutex                      connection_mutex;
            std::condition_variable         connection_cv;
            bool                            connection_is_open, connection_attempt_failed;
            WebsocketClient::connection_ptr connection;
            websocketpp::connection_hdl     our_connection_hdl;
            
            void on_client_open(websocketpp::connection_hdl hdl);
            void on_client_fail(websocketpp::connection_hdl hdl);
            void on_client_close(websocketpp::connection_hdl hdl);
            void on_client_message(websocketpp::connection_hdl hdl, message_ptr msg);
 
            std::ostringstream out_;
            
            Snoop::AppEntry    this_app_;
            Snoop::LogEntry    this_log_;
            std::string        server_;
 
         std::recursive_mutex   call_mutex;
            bool         secure;
 
          std::set<std::string> local_types;
//        std::set<std::string> ...
         std::function<void (std::string, bool)> authentication_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__