syslogmessage.h

Go to the documentation of this file.

/*
 * Copyright 2022 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */
#pragma once
#include <cstdint>
#include <string>
#include <vector>
 
#include "logmessage.h"
#include "structureddata.h"
namespace util::syslog {

enum class SyslogSeverity : uint8_t {
  Emergency = 0,      
  Alert = 1,          
  Critical = 2,       
  Error = 3,          
  Warning = 4,        
  Notice = 5,         
  Informational = 6,  
  Debug = 7           
};

enum class SyslogFacility : uint8_t {
  Kernel = 0,
  UserLevel = 1,
  Mail = 2,
  SystemDaemon = 3,
  Security = 4,
  Internal = 5,
  Printer = 6,
  Network = 7,
  UUCP = 8,
  Clock = 9,
  Authorization = 10,
  FTP = 11,
  NTP = 12,
  LogAudit = 13,
  LogAlert = 14,
  ClockDaemon = 15,
  Local0 = 16,
  Local1 = 17,
  Local2 = 18,
  Local3 = 19,
  Local4 = 20,
  Local5 = 21,
  Local6 = 22,
  Local7 = 23
};

class SyslogMessage {
 public:
  SyslogMessage();
 
  SyslogMessage(const SyslogMessage&) = default; 

  SyslogMessage(const util::log::LogMessage& log, bool show_location);
 
  virtual ~SyslogMessage() = default;  

  void Index(int64_t index) {index_ = index;}
 
  [[nodiscard]] int64_t Index() const {return index_;} 
 
  void Severity(SyslogSeverity severity) {  
    severity_ = severity;
  }
  [[nodiscard]] SyslogSeverity Severity()
      const {  
    return severity_;
  }
 
  void Facility(SyslogFacility facility) {  
    facility_ = facility;
  }
 
  [[nodiscard]] SyslogFacility Facility()
      const {  
    return facility_;
  }
 
  [[nodiscard]] uint8_t Version() const {  
    return version_;
  }
 
  void Timestamp(uint64_t ns1970) {  
    timestamp_ = ns1970;
  }
 
  [[nodiscard]] uint64_t Timestamp()
      const {  
    return timestamp_;
  }
 
  void Hostname(const std::string& name);  
  [[nodiscard]] const std::string& Hostname()
      const {  
    return hostname_;
  }
 
  void ApplicationName(const std::string& name);  
  [[nodiscard]] const std::string& ApplicationName()
      const {  
    return application_name_;
  }
 
  void ProcessId(const std::string& pid);               
  [[nodiscard]] const std::string& ProcessId() const {  
    return process_id_;
  }
 
  void MessageId(const std::string& msg_id);  
  [[nodiscard]] const std::string& MessageId()
      const {  
    return message_id_;
  }

  void Message(const std::string& msg);

  [[nodiscard]] const std::string& Message() const { return message_; }
 
  void AddData(
      const StructuredData& data) {  
    sd_list_.push_back(data);
  }
 
  [[nodiscard]] const std::vector<StructuredData>& DataList()
      const {  
    return sd_list_;
  }
 
  [[nodiscard]] std::string GenerateMessage()
      const;                                  
  bool ParseMessage(const std::string& msg);  
 
  void AddStructuredData(
      const std::string&
          identity);  
  void AppendParameter(const std::string& name,
                       const std::string& value);  
  void Version(uint8_t version) {  
    version_ = version;
  }

  void IsoTime(const std::string& iso_time);
 
 protected:
 private:
  int64_t index_ = 0; 
  SyslogSeverity severity_ = SyslogSeverity::Informational;
  SyslogFacility facility_ = SyslogFacility::Local0;
  uint8_t version_ = 1;
  uint64_t timestamp_ = 0;
  std::string hostname_;
  std::string application_name_;
  std::string process_id_;
  std::string message_id_;
 
  std::string message_;
 
  std::vector<StructuredData> sd_list_;
};
 
}  // namespace util::syslog