logs

JxcClient.pro

@@ -15,6 +15,8 @@ DEFINES += QT_DEPRECATED_WARNINGS
 # You can also select to disable deprecated APIs only up to a certain version of Qt.
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
 
+include($$PWD/QLog/QLogClass.pri)
+
 SOURCES += \
     configinfo.cpp \
     globalinfo.cpp \

QLog/QLogClass.pri

@@ -0,0 +1,4 @@
+CONFIG += c++11
+SOURCES += $$PWD/qlog.cpp
+HEADERS += $$PWD/qlog.h
+INCLUDEPATH += $$PWD

QLog/qlog.cpp

@@ -0,0 +1,340 @@
+#include "qlog.h"
+#include <QTime>
+#include <QEvent>
+#include <QThread>
+#include <QCoreApplication>
+#include <iostream>
+#include <QDir>
+#include <QDate>
+#include <memory>
+#include <QDebug>
+#include <QDateTime>
+
+namespace QLOG {
+
+static const char * LevelName[6] = {"Test","Debug","Info","Warning","Critical","Fatal"};
+
+void customMessageHandler(QtMsgType type, const QMessageLogContext &context,const QString & msg)
+{
+    auto log = QLogManger::this_()->qDebugLog();
+    switch (type) {
+    //调试信息提示
+    case QtDebugMsg:
+        if (log->checkLevel(DebugMsg)) {
+            LogMessage(log,context.file,context.line,DebugMsg).stream()  << msg ;
+        }
+        break;
+        //一般的warning提示
+    case QtWarningMsg:
+        if (log->checkLevel(WarningMsg)) {
+            LogMessage(log,context.file,context.line,WarningMsg).stream() << msg ;
+        }
+        break;
+        //严重错误提示
+    case QtCriticalMsg:
+        if (log->checkLevel(CriticalMsg)) {
+            LogMessage(log,context.file,context.line,CriticalMsg).stream() << msg ;
+        }
+        break;
+        //致命错误提示
+    case QtFatalMsg:
+        if (log->checkLevel(FatalMsg)) {
+            LogMessage(log,context.file,context.line,FatalMsg).stream() << msg ;
+        }
+        break;
+    case QtInfoMsg :
+        if (log->checkLevel(InfoMsg)) {
+            LogMessage(log,context.file,context.line,InfoMsg).stream() << msg ;
+        }
+        break;
+    }
+}
+
+QLogManger::QLogManger()
+{
+    _thread.start();
+    auto nm = QCoreApplication::applicationName();
+    _baseLog.reset(new QLog(nm,STD_OUT));
+    _baseLog->moveToThread(&_thread);
+    _qtLog.reset(new QLog("qtdebug",STD_OUT));
+    _qtLog->moveToThread(&_thread);
+    _logs.insert(nm,_baseLog);
+    _logs.insert("qtdebug",_qtLog);
+    connect(this,&QLogManger::updateSavePath,_baseLog.data(),&QLog::restLog,Qt::QueuedConnection);
+    connect(this,&QLogManger::updateSavePath,_qtLog.data(),&QLog::restLog,Qt::QueuedConnection);
+    setSaveFilePath(QDir::homePath() + "/qlog");
+}
+
+QLogManger * QLogManger::this_()
+{
+    static QLogManger logManger;
+    return &logManger;
+}
+
+QLogManger::~QLogManger()
+{
+    _thread.quit();
+    _thread.wait(1000);
+    if(_thread.isRunning()){
+        _thread.terminate();
+    }
+}
+
+bool QLogManger::setSaveFilePath(const QString & path)
+{
+    QDir dir(path);
+    if(dir.exists() || dir.mkpath(dir.absolutePath())) {
+        QFileInfo info(path);
+        if(info.isWritable()){
+            path_ = dir.absolutePath();
+            emit updateSavePath();
+        }
+    }
+    return false;
+}
+
+QLog * QLogManger::enbleQtMessage()
+{
+    qInstallMessageHandler(customMessageHandler);
+    return _qtLog.data();
+}
+
+QLog * QLogManger::getLog(const QString & name)
+{
+    _locker.lockForRead();
+    auto log = _logs.value(name);
+    _locker.unlock();
+    if(log.isNull()){
+        _locker.lockForWrite();
+        log = _logs.value(name);
+        if(log.isNull()){
+            log.reset(new QLog(name));
+            log->moveToThread(&_thread);
+            connect(this,&QLogManger::updateSavePath,log.data(),&QLog::restLog,Qt::QueuedConnection);
+            _logs.insert(name,log);
+        }
+        _locker.unlock();
+    }
+    return log.data();
+}
+
+class LogEvent : public QEvent
+{
+public:
+    LogEvent(QString && str,LogLevel lv): QEvent(eventType),level(lv),str_(str) {}
+    ~LogEvent() {}
+
+    const QString & getString() const {return str_;}
+
+    static QEvent::Type eventType;
+    LogLevel level;
+private:
+    QString str_;
+};
+
+QEvent::Type LogEvent::eventType = static_cast<QEvent::Type>(QEvent::registerEventType());
+
+class UpEventOutStatus : public QEvent
+{
+public:
+    UpEventOutStatus(OutState state): QEvent(eventType),state(state) {}
+    ~UpEventOutStatus() {}
+
+
+    static QEvent::Type eventType;
+    OutState state;
+};
+
+QEvent::Type UpEventOutStatus::eventType = static_cast<QEvent::Type>(QEvent::registerEventType());
+
+LogMessage::LogMessage(QLog * log,const char * file, int line,LogLevel level) : log(log), ts(&str_),level_(level)
+{
+    if(log == nullptr || level < log->level) return;
+    if(log->writeTime){
+        ts << "[" << QTime::currentTime().toString("hh:mm:ss.zzz") << "]:";
+    }
+    if(log->writeFileInfo) {
+        ts << "[@ " << file << " : " << line << "]:";
+    }
+    if(log->writeLevel){
+        ts << "[" << LevelName[level] << "]:";
+    }
+}
+
+LogMessage::LogMessage(QLog * log,LogLevel level): log(log), ts(&str_),level_(level)
+{
+    if(log == nullptr || level < log->level) return;
+    if(log->writeTime){
+        ts << "[" << QTime::currentTime().toString("hh:mm:ss.zzz") << "]:";
+    }
+    if(log->writeFileInfo) {
+        ts << "[@ ]:";
+    }
+    if(log->writeLevel){
+        ts << "[" << LevelName[level] << "]:";
+    }
+}
+
+LogMessage::~LogMessage()
+{
+    if (log != nullptr && level_ >= log->level ) {
+        if(log->writeEndLine)
+            ts << "\r\n";
+        ts.setDevice(nullptr);
+        QCoreApplication::postEvent(log,new LogEvent(std::move(str_),level_));
+        if (level_ == FatalMsg) {
+            QCoreApplication::exit(-1);
+        }
+    }
+}
+
+
+QLog::QLog(const QString & name, OutState state)
+        : QObject(nullptr),state_(state),file_(nullptr),_name(name)
+{
+    level = TestMsg;
+    writeTime = true;
+    writeFileInfo = true;
+    writeLevel = true;
+    writeEndLine = true;
+    fileCreateType = DayOne;
+    ts_.setDevice(nullptr);
+    _fileCreateId = -1;
+}
+
+QLog::~QLog()
+{
+    releaseLogFile();
+
+}
+
+void QLog::setOutState(OutState outState)
+{
+    QCoreApplication::postEvent(this,new UpEventOutStatus(outState));
+}
+
+void QLog::restLog()
+{
+    if(state_ == File){
+        releaseLogFile();
+    }
+}
+
+void QLog::releaseLogFile()
+{
+  ts_.setDevice(nullptr);
+  if(file_){
+      file_->close();
+      delete file_;
+      file_ = nullptr;
+  }
+}
+
+void QLog::customEvent(QEvent * event)
+{
+    if(event->type() == UpEventOutStatus::eventType){
+        UpEventOutStatus * ev = static_cast<UpEventOutStatus *>(event);
+        if(state_ != ev->state) {
+            state_ = ev->state;
+            releaseLogFile();
+
+        }
+    } else if (event->type() == LogEvent::eventType) {
+        LogEvent * ev = static_cast<LogEvent *>(event);
+        if(ev->level >= level) {
+            switch (state_) {
+            case STD_OUT :{
+                if(file_ == nullptr){
+                    file_ = new QFile(this);
+                    file_->open(1,QFile::Append);
+                    ts_.setDevice(file_);
+                }
+            }
+                break;
+            case STD_ERROR:{
+                if(file_ == nullptr){
+                    if(file_ == nullptr){
+                        file_ = new QFile(this);
+                        file_->open(2,QFile::Append);
+                        ts_.setDevice(file_);
+                    }
+                }
+            }
+                break;
+            case File : {
+                if(file_){
+                    int id = _fileCreateId;
+                    switch (fileCreateType) {
+                    case DayOne: {
+                        id = QDate::currentDate().day();
+                    }
+                        break;
+                    case HourOne:
+                        id = QTime::currentTime().hour();
+                        break;
+                    case MonthOne:
+                        id = QDate::currentDate().month();
+                        break;
+                    default:
+                        id = _fileCreateId;
+                        break;
+                    }
+                    if(id != _fileCreateId)
+                        releaseLogFile();
+                }
+                if(file_ == nullptr){
+                    QString fname = QLogManger::this_()->getSaveFilePath() + "/" + _name;
+                    switch (fileCreateType) {
+                    case OneStartOne:{
+                        auto pid = QCoreApplication::applicationPid();
+                        fname += "_";
+                        fname += QDateTime::currentDateTime().toString("yyyy-MM-dd.hh-mm-ss.zzz");
+                        fname += "_";
+                        fname += QString::number(pid);
+                        _fileCreateId = 0;
+                    }
+                    case DayOne: {
+                        auto dt = QDate::currentDate();
+                        fname += "_";
+                        fname += dt.toString("yyyy-MM-dd");
+                        _fileCreateId = dt.day();
+                    }
+                        break;
+                    case HourOne:{
+                        auto dt = QDateTime::currentDateTime();
+                        fname += "_";
+                        fname += dt.toString("yyyy-MM-dd.hh");
+                        _fileCreateId = dt.time().hour();
+                    }
+                        break;
+                    case MonthOne:{
+                        auto dt = QDate::currentDate();
+                        fname += "_";
+                        fname += dt.toString("yyyy-MM");
+                        _fileCreateId = dt.month();
+                    }
+                        break;
+                    default:
+                        break;
+                    }
+                    fname += ".logs";
+                    file_ = new QFile(fname,this);
+                    file_->open(QFile::Append);
+                    ts_.setDevice(file_);
+                }
+            }
+            break;
+        default:
+            break;
+        }
+        if (ts_.device() != nullptr) {
+            ts_ << ev->getString();
+            ts_.flush();
+        }
+        }
+    }
+    event->accept();
+
+}
+
+}//namespace QLOG

QLog/qlog.h

@@ -0,0 +1,164 @@
+#ifndef QLOG_H
+#define QLOG_H
+
+#include <QObject>
+#include <QTextStream>
+#include <QFile>
+#include <QCoreApplication>
+#include <QSharedPointer>
+#include <QReadWriteLock>
+#include <QThread>
+
+//QtDebugMsg	0	A message generated by the qDebug() function.
+//QtInfoMsg	    4	A message generated by the qInfo() function.
+//QtWarningMsg	1	A message generated by the qWarning() function.
+//QtCriticalMsg	2	A message generated by the qCritical() function.
+//QtFatalMsg	3	A message generated by the qFatal() function.
+
+
+
+#define LOG(log,Level) if (log->checkLevel(Level)) \
+    QLOG::LogMessage(log,__FILE__, __LINE__,Level).stream()
+
+#define QLogTest(log) LOG(log,QLOG::TestMsg)
+#define QLogDebug(log) LOG(log,QLOG::DebugMsg)
+#define QLogInfo(log) LOG(log,QLOG::InfoMsg)
+#define QLogWarning(log) LOG(log,QLOG::WarningMsg)
+#define QLogCritical(log) LOG(log,QLOG::CriticalMsg)
+#define QLogFatal(log) LOG(log,QLOG::FatalMsg)
+
+#define LOGD(Level) if (QLOG::QLogManger::this_()->baseLog()->checkLevel(Level)) \
+    QLOG::LogMessage(QLOG::QLogManger::this_()->baseLog(),__FILE__, __LINE__,Level).stream()
+
+#define QDTest LOGD(QLOG::TestMsg)
+#define QDDebug LOGD(QLOG::DebugMsg)
+#define QDInfo LOGD(QLOG::InfoMsg)
+#define QDWarning LOGD(QLOG::WarningMsg)
+#define QDCritical LOGD(QLOG::CriticalMsg)
+#define QDFatal LOGD(QLOG::FatalMsg)
+
+namespace QLOG {
+class QLog;
+
+enum LogLevel{
+    TestMsg = 0,
+    DebugMsg = 1,
+    InfoMsg = 2,
+    WarningMsg = 3,
+    CriticalMsg = 4,
+    FatalMsg = 5,
+};
+
+enum OutState{
+    STD_OUT = 0,
+    STD_ERROR = 1,
+    File = 2
+};
+
+enum FileCreateType
+{
+    OnlyOne,
+    OneStartOne,
+    DayOne,
+    HourOne,
+    MonthOne
+};
+
+
+
+class LogMessage
+{
+public:
+    LogMessage(QLog * log, const char * file, int line, LogLevel level);
+    LogMessage(QLog * log,LogLevel level);
+    ~LogMessage();
+    inline QTextStream & stream() {return ts;}
+private:
+    QLog * log;
+    QString str_;
+    QTextStream ts;
+    LogLevel level_;
+};
+
+class LogEvent;
+
+
+// TODO:
+class QLogManger : public QObject
+{
+    Q_OBJECT
+public:
+    ~QLogManger();
+
+    static QLogManger * this_();
+
+    inline QLog * baseLog()const {
+        return _baseLog.data();
+    }
+
+    inline QLog * qDebugLog()const {
+        return _baseLog.data();
+    }
+
+    bool setSaveFilePath(const QString & path);
+
+    QLog * enbleQtMessage();
+
+    QLog * getLog(const QString & name);
+
+    inline QString getSaveFilePath() const {return path_;}
+signals:
+    void updateSavePath();
+private:
+    QString path_;
+    QLogManger();
+    QReadWriteLock _locker;
+    QHash<QString, QSharedPointer<QLog>> _logs;
+    QSharedPointer<QLog> _baseLog;
+    QSharedPointer<QLog> _qtLog;
+    QThread _thread;
+};
+
+class QLog : public QObject
+{
+    Q_OBJECT
+public:
+    ~QLog();
+    inline  bool checkLevel(LogLevel level) {
+        if (level < this->level) {
+            return false;
+        }
+        return true;
+    }
+
+    bool writeTime;
+    bool writeFileInfo;
+    bool writeLevel;
+    bool writeEndLine;
+    LogLevel level;
+    FileCreateType fileCreateType;;
+
+    void setOutState(OutState outState);
+    inline OutState getOutState() const {return state_;}
+protected:
+    void customEvent(QEvent * event);
+
+protected slots:
+    void restLog();
+
+    void releaseLogFile();
+private:
+    OutState state_;
+    QFile * file_;
+    QTextStream ts_;
+    QString _name;
+    int  _fileCreateId;
+private:
+    explicit QLog(const QString & name,OutState state = File);
+    friend class QLogManger;
+    friend class LogMessage;
+};
+
+} //namespace QLOG
+
+#endif // QLOG_H

handle/seriport/assictscalet2000.cpp

@@ -1,6 +1,7 @@
 #include "assictscalet2000.h"
 #include <QList>
 #include "globalinfo.h"
+#include <QLog/qlog.h>
 
 AssicTScaleT2000::AssicTScaleT2000()
 {
@@ -60,7 +61,7 @@ void AssicTScaleT2000::readData(QByteArray & data)
     const char * from = buff.constData();
     const char *to = from + buff.size();
     const char *inner;
-
+    QDInfo << data ;
     // Token is a sequence of numbers.
     for (inner = from; inner != to; ++inner)
         if (*inner != '.' && (*inner < '0' || *inner > '9'))

handle/seriport/serialbasehandle.cpp

@@ -1,6 +1,7 @@
 #include "serialbasehandle.h"
 #include "logserialport.h"
 #include "assictscalet2000.h"
+#include <QLog/qlog.h>
 
 SerialBaseHandle::SerialBaseHandle()
 {
@@ -15,6 +16,7 @@ SerialBaseHandle::~SerialBaseHandle()
 
 SerialBaseHandle * SerialBaseHandle::getHandler(int type, const QString & result)
 {
+    QDInfo << " getHandler <<" << type;
     SerialBaseHandle *ret = nullptr;
     switch (type) {
         case 0:

main.cpp

@@ -1,10 +1,15 @@
 #include "mainwindow.h"
 
 #include <QApplication>
+#include <QLog/qlog.h>
 
 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
+    auto qtlog = QLOG::QLogManger::this_()->qDebugLog();
+    qtlog->setOutState(QLOG::File);
+    auto log = QLOG::QLogManger::this_()->baseLog();
+    log->setOutState(QLOG::File);
         MainWindow w;
         w.show();
     return a.exec();