HPCC-14681 Add new updateLog method to ESP logging manager

1. The new updateLog method allows the updateLog request wth two
parameters. One is in IPropertyTree* format and the other is in
IInterface* format. 2. Support NoResend option.

Signed-off-by: wangkx <kevin.wang@lexisnexis.com>

esp/logging/logginglib/loggingagentbase.hpp

@@ -42,19 +42,25 @@ interface IEspUpdateLogRequestWrap : extends IInterface
     virtual IPropertyTree* getESPContext()=0;
     virtual IPropertyTree* getUserContext()=0;
     virtual IPropertyTree* getUserRequest()=0;
+    virtual IPropertyTree* getLogRequestTree()=0;
+    virtual IInterface* getExtraLog()=0;
     virtual const char* getBackEndResponse()=0;
     virtual const char* getUserResponse()=0;
     virtual const char* getLogDatasets()=0;
+    virtual const bool getNoResend()=0;
     virtual void setGUID(const char* val)=0;
     virtual void setOption(const char* val)=0;
     virtual void setUpdateLogRequest(const char* val)=0;
     virtual void setESPContext(IPropertyTree* val)=0;
     virtual void setUserContext(IPropertyTree* val)=0;
     virtual void setUserRequest(IPropertyTree* val)=0;
+    virtual void setLogRequestTree(IPropertyTree* val)=0;
+    virtual void setExtraLog(IInterface* val)=0;
     virtual void setBackEndResponse(const char* val)=0;
     virtual void setUserResponse(const char* val)=0;
     virtual void setLogDatasets(const char* val)=0;
     virtual unsigned incrementRetryCount() = 0;
+    virtual void setNoResend(bool val)=0;
     virtual void clearOriginalContent() = 0;
 };
 
@@ -66,10 +72,13 @@ class CUpdateLogRequestWrap : implements IEspUpdateLogRequestWrap, public CInter
     Owned<IPropertyTree> espContext;
     Owned<IPropertyTree> userContext;
     Owned<IPropertyTree> userRequest;
+    Owned<IPropertyTree> logRequestTree;
+    Owned<IInterface> extraLog;
     StringAttr  backEndResponse;
     StringAttr  userResponse;
     StringAttr  logDatasets;
     unsigned    retryCount;
+    bool        noResend = false;;
 
 public:
     IMPLEMENT_IINTERFACE;
@@ -86,12 +95,13 @@ public:
         espContext.setown(_espContext);
         userRequest.setown(_userRequest);
     };
-    ~CUpdateLogRequestWrap()
+    CUpdateLogRequestWrap(const char* _GUID, const char* _option, IPropertyTree* _logInfo,
+        IInterface* _extraLog) : GUID(_GUID), option(_option), retryCount(0)
     {
-        espContext.clear();
-        userRequest.clear();
-        userContext.clear();
+        logRequestTree.setown(_logInfo);
+        extraLog.setown(_extraLog);
     };
+
     void clearOriginalContent()
     {
         espContext.clear();
@@ -101,6 +111,8 @@ public:
         logDatasets.clear();
         backEndResponse.clear();
         updateLogRequest.clear();
+        logRequestTree.clear();
+        extraLog.clear();
     };
 
     const char* getGUID() {return GUID.get();};
@@ -109,19 +121,25 @@ public:
     IPropertyTree* getESPContext() {return espContext.getLink();};
     IPropertyTree* getUserContext() {return userContext.getLink();};
     IPropertyTree* getUserRequest() {return userRequest.getLink();};
+    IPropertyTree* getLogRequestTree() {return logRequestTree.getLink();};
+    IInterface* getExtraLog() {return extraLog.getLink();};
     const char* getBackEndResponse() {return backEndResponse.get();};
     const char* getUserResponse() {return userResponse.get();};
     const char* getLogDatasets() {return logDatasets.get();};
+    const bool getNoResend() {return noResend;};
     void setGUID(const char* val) {GUID.set(val);};
     void setOption(const char* val) {option.set(val);};
     void setUpdateLogRequest(const char* val) {updateLogRequest.set(val);};
     void setESPContext(IPropertyTree* val) {espContext.setown(val);};
     void setUserContext(IPropertyTree* val) {userContext.setown(val);};
     void setUserRequest(IPropertyTree* val) {userRequest.setown(val);};
+    void setLogRequestTree(IPropertyTree* val) {logRequestTree.setown(val);};
+    void setExtraLog(IInterface* val) {extraLog.setown(val);};
     void setBackEndResponse(const char* val) {backEndResponse.set(val);};
     void setUserResponse(const char* val) {userResponse.set(val);};
     void setLogDatasets(const char* val) {logDatasets.set(val);};
     unsigned incrementRetryCount() { retryCount++; return retryCount;};
+    void setNoResend(bool val) { noResend = val; };
 };
 
 interface IEspLogAgent : extends IInterface

esp/logging/logginglib/logthread.cpp

@@ -231,7 +231,7 @@ void CLogThread::sendLog()
                 e->Release();
 
                 bool willRetry = false;
-                if (maxLogRetries != 0)
+                if (!logRequest->getNoResend() && (maxLogRetries != 0))
                 {
                     unsigned retry = logRequest->incrementRetryCount();
                     if (retry > maxLogRetries)

esp/logging/loggingmanager/loggingmanager.cpp

@@ -83,7 +83,24 @@ IEspLogAgent* CLoggingManager::loadLoggingAgent(const char* name, const char* dl
     return (IEspLogAgent*) xproc();
 }
 
-bool CLoggingManager::updateLog(IEspContext& espContext, const char* option, const char* logContent, StringBuffer& status)
+IEspLogEntry* CLoggingManager::createLogEntry()
+{
+    return new CEspLogEntry();
+}
+
+bool CLoggingManager::updateLog(IEspLogEntry* entry, StringBuffer& status)
+{
+    if (entry->getLogContent())
+        return updateLog(entry->getEspContext(), entry->getOption(), entry->getLogContent(), status);
+
+    if (entry->getLogInfoTree())
+        return updateLog(entry->getEspContext(), entry->getOption(), entry->getLogInfoTree(), entry->getExtraLog(), status);
+
+    return updateLog(entry->getEspContext(), entry->getOption(), entry->getUserContextTree(), entry->getUserRequestTree(),
+        entry->getBackEndResp(), entry->getUserResp(), entry->getLogDatasets(), status);
+}
+
+bool CLoggingManager::updateLog(IEspContext* espContext, const char* option, const char* logContent, StringBuffer& status)
 {
     if (!initialized)
         throw MakeStringException(-1,"LoggingManager not initialized");
@@ -91,14 +108,14 @@ bool CLoggingManager::updateLog(IEspContext& espContext, const char* option, con
     bool bRet = false;
     try
     {
-        Owned<IEspUpdateLogRequestWrap> req =  new CUpdateLogRequestWrap(NULL, option, logContent);
+        Owned<IEspUpdateLogRequestWrap> req =  new CUpdateLogRequestWrap(nullptr, option, logContent);
         Owned<IEspUpdateLogResponse> resp =  createUpdateLogResponse();
         bRet = updateLog(espContext, *req, *resp, status);
     }
     catch (IException* e)
     {
+        status.set("Failed to update log: ");
         e->errorMessage(status);
-        status.insert(0, "Failed to update log: ");
         ERRLOG("%s", status.str());
         e->Release();
     }
@@ -106,7 +123,30 @@ bool CLoggingManager::updateLog(IEspContext& espContext, const char* option, con
     return bRet;
 }
 
-bool CLoggingManager::updateLog(const char* option, IEspContext& espContext, IPropertyTree* userContext, IPropertyTree* userRequest,
+bool CLoggingManager::updateLog(IEspContext* espContext, const char* option, IPropertyTree* logInfo, IInterface* extraLog, StringBuffer& status)
+{
+    if (!initialized)
+        throw MakeStringException(-1,"LoggingManager not initialized");
+
+    bool bRet = false;
+    try
+    {
+        Owned<IEspUpdateLogRequestWrap> req =  new CUpdateLogRequestWrap(nullptr, option, LINK(logInfo), LINK(extraLog));
+        Owned<IEspUpdateLogResponse> resp =  createUpdateLogResponse();
+        bRet = updateLog(espContext, *req, *resp, status);
+    }
+    catch (IException* e)
+    {
+        status.set("Failed to update log: ");
+        e->errorMessage(status);
+        ERRLOG("%s", status.str());
+        e->Release();
+    }
+
+    return bRet;
+}
+
+bool CLoggingManager::updateLog(IEspContext* espContext, const char* option, IPropertyTree* userContext, IPropertyTree* userRequest,
         const char* backEndResp, const char* userResp, const char* logDatasets, StringBuffer& status)
 {
     if (!initialized)
@@ -115,33 +155,38 @@ bool CLoggingManager::updateLog(const char* option, IEspContext& espContext, IPr
     bool bRet = false;
     try
     {
-        short port;
-        StringBuffer sourceIP;
-        espContext.getServAddress(sourceIP, port);
-        Owned<IPropertyTree> espContextTree = createPTree("ESPContext");
-        espContextTree->addProp("SourceIP", sourceIP.str());
-        const char* userId = espContext.queryUserId();
-        if (userId && *userId)
-            espContextTree->addProp("UserName", userId);
-
-        espContextTree->addProp("ResponseTime", VStringBuffer("%.4f", (msTick()-espContext.queryCreationTime())/1000.0));
-
-        Owned<IEspUpdateLogRequestWrap> req =  new CUpdateLogRequestWrap(NULL, option, espContextTree.getClear(), LINK(userContext), LINK(userRequest),
+        Owned<IPropertyTree> espContextTree;
+        if (espContext)
+        {
+            espContextTree.setown(createPTree("ESPContext"));
+
+            short port;
+            StringBuffer sourceIP;
+            espContext->getServAddress(sourceIP, port);
+            espContextTree->addProp("SourceIP", sourceIP.str());
+
+            const char* userId = espContext->queryUserId();
+            if (userId && *userId)
+                espContextTree->addProp("UserName", userId);
+
+            espContextTree->addProp("ResponseTime", VStringBuffer("%.4f", (msTick()-espContext->queryCreationTime())/1000.0));
+        }
+        Owned<IEspUpdateLogRequestWrap> req =  new CUpdateLogRequestWrap(nullptr, option, espContextTree.getClear(), LINK(userContext), LINK(userRequest),
             backEndResp, userResp, logDatasets);
         Owned<IEspUpdateLogResponse> resp =  createUpdateLogResponse();
         bRet = updateLog(espContext, *req, *resp, status);
     }
     catch (IException* e)
     {
+        status.set("Failed to update log: ");
         e->errorMessage(status);
-        status.insert(0, "Failed to update log: ");
         ERRLOG("%s", status.str());
         e->Release();
     }
     return bRet;
 }
 
-bool CLoggingManager::updateLog(IEspContext& espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp, StringBuffer& status)
+bool CLoggingManager::updateLog(IEspContext* espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp, StringBuffer& status)
 {
     bool bRet = updateLog(espContext, req, resp);
     if (bRet)
@@ -157,7 +202,7 @@ bool CLoggingManager::updateLog(IEspContext& espContext, IEspUpdateLogRequestWra
     return bRet;
 }
 
-bool CLoggingManager::updateLog(IEspContext& espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp)
+bool CLoggingManager::updateLog(IEspContext* espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp)
 {
     if (!initialized)
         throw MakeStringException(-1,"LoggingManager not initialized");
@@ -165,7 +210,8 @@ bool CLoggingManager::updateLog(IEspContext& espContext, IEspUpdateLogRequestWra
     bool bRet = false;
     try
     {
-        espContext.addTraceSummaryTimeStamp(LogMin, "LMgr:startQLog");
+        if (espContext)
+            espContext->addTraceSummaryTimeStamp(LogMin, "LMgr:startQLog");
         for (unsigned int x = 0; x < loggingAgentThreads.size(); x++)
         {
             IUpdateLogThread* loggingThread = loggingAgentThreads[x];
@@ -175,7 +221,8 @@ bool CLoggingManager::updateLog(IEspContext& espContext, IEspUpdateLogRequestWra
                 bRet = true;
             }
         }
-        espContext.addTraceSummaryTimeStamp(LogMin, "LMgr:endQLog");
+        if (espContext)
+            espContext->addTraceSummaryTimeStamp(LogMin, "LMgr:endQLog");
     }
     catch (IException* e)
     {

esp/logging/loggingmanager/loggingmanager.h

@@ -25,13 +25,37 @@
 #define LOGGINGMANAGERLIB "loggingmanager"
 #define LOGGINGDBSINGLEINSERT "SingleInsert"
 
+interface IEspLogEntry  : implements IInterface
+{
+    virtual void setEspContext(IEspContext* ctx)  = 0;
+    virtual void setUserContextTree(IPropertyTree* tree) = 0;
+    virtual void setUserRequestTree(IPropertyTree* tree) = 0;
+    virtual void setLogInfoTree(IPropertyTree* tree) = 0;
+    virtual void setExtraLog(IInterface* extra) = 0;
+    virtual void setOption(const char* ptr) = 0;
+    virtual void setLogContent(const char* ptr) = 0;
+    virtual void setBackEndResp(const char* ptr) = 0;
+    virtual void setUserResp(const char* ptr) = 0;
+    virtual void setLogDatasets(const char* ptr) = 0;
+
+    virtual IEspContext* getEspContext() = 0;
+    virtual IPropertyTree* getUserContextTree() = 0;
+    virtual IPropertyTree* getUserRequestTree() = 0;
+    virtual IPropertyTree* getLogInfoTree() = 0;
+    virtual IInterface* getExtraLog() = 0;
+    virtual const char* getOption() = 0;
+    virtual const char* getLogContent() = 0;
+    virtual const char* getBackEndResp() = 0;
+    virtual const char* getUserResp() = 0;
+    virtual const char* getLogDatasets() = 0;
+};
+
 interface ILoggingManager : implements IInterface
 {
     virtual bool init(IPropertyTree* loggingConfig, const char* service) = 0;
-    virtual bool updateLog(IEspContext& espContext, const char* option, const char* logContent, StringBuffer& status) = 0;
-    virtual bool updateLog(const char* option, IEspContext& espContext, IPropertyTree* userContext, IPropertyTree* userRequest,
-        const char* backEndResp, const char* userResp, const char* logDatasets, StringBuffer& status) = 0;
-    virtual bool updateLog(IEspContext& espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp) = 0;
+    virtual IEspLogEntry* createLogEntry() = 0;
+    virtual bool updateLog(IEspLogEntry* entry, StringBuffer& status) = 0;
+    virtual bool updateLog(IEspContext* espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp) = 0;
     virtual bool getTransactionSeed(StringBuffer& transactionSeed, StringBuffer& status) = 0;
     virtual bool getTransactionSeed(IEspGetTransactionSeedRequest& req, IEspGetTransactionSeedResponse& resp) = 0;
     virtual bool getTransactionID(StringAttrMapping* transFields, StringBuffer& transactionID, StringBuffer& status) = 0;

esp/logging/loggingmanager/loggingmanager.hpp

@@ -31,6 +31,43 @@
     #define LOGGINGMANAGER_API DECL_IMPORT
 #endif
 
+class CEspLogEntry : implements IEspLogEntry, public CInterface
+{
+    Owned<IEspContext> espContext;
+    StringAttr option, logContent, backEndResp, userResp, logDatasets;
+    Owned<IPropertyTree> userContextTree;
+    Owned<IPropertyTree> userRequestTree;
+    Owned<IPropertyTree> logInfoTree;
+    Owned<IInterface> extraLog;
+
+public:
+    IMPLEMENT_IINTERFACE;
+
+    CEspLogEntry(void) { };
+
+    void setEspContext(IEspContext* ctx) { espContext.setown(ctx); };
+    void setUserContextTree(IPropertyTree* tree) { userContextTree.setown(tree); };
+    void setUserRequestTree(IPropertyTree* tree) { userRequestTree.setown(tree); };
+    void setLogInfoTree(IPropertyTree* tree) { logInfoTree.setown(tree); };
+    void setExtraLog(IInterface* extra) { extraLog.setown(extra); };
+    void setOption(const char* ptr) { option.set(ptr); };
+    void setLogContent(const char* ptr) { logContent.set(ptr); };
+    void setBackEndResp(const char* ptr) { backEndResp.set(ptr); };
+    void setUserResp(const char* ptr) { userResp.set(ptr); };
+    void setLogDatasets(const char* ptr) { logDatasets.set(ptr); };
+
+    IEspContext* getEspContext() { return espContext; };
+    IPropertyTree* getUserContextTree() { return userContextTree; };
+    IPropertyTree* getUserRequestTree() { return userRequestTree; };
+    IPropertyTree* getLogInfoTree() { return logInfoTree; };
+    IInterface* getExtraLog() { return extraLog; };
+    const char* getOption() { return option.get(); };
+    const char* getLogContent() { return logContent.get(); };
+    const char* getBackEndResp() { return backEndResp.get(); };
+    const char* getUserResp() { return userResp.get(); };
+    const char* getLogDatasets() { return logDatasets.get(); };
+};
+
 
 class CLoggingManager : implements ILoggingManager, public CInterface
 {
@@ -39,7 +76,13 @@ class CLoggingManager : implements ILoggingManager, public CInterface
     bool initialized;
 
     IEspLogAgent* loadLoggingAgent(const char* name, const char* dll, const char* type, IPropertyTree* cfg);
-    bool updateLog(IEspContext& espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp, StringBuffer& status);
+    bool updateLogImpl(IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp);
+
+    bool updateLog(IEspContext* espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp, StringBuffer& status);
+    bool updateLog(IEspContext* espContext, const char* option, IPropertyTree* userContext, IPropertyTree* userRequest,
+        const char* backEndResp, const char* userResp, const char* logDatasets, StringBuffer& status);
+    bool updateLog(IEspContext* espContext, const char* option, const char* logContent, StringBuffer& status);
+    bool updateLog(IEspContext* espContext, const char* option, IPropertyTree* logInfo, IInterface* extraLog, StringBuffer& status);
 
 public:
     IMPLEMENT_IINTERFACE;
@@ -49,10 +92,9 @@ public:
 
     virtual bool init(IPropertyTree* cfg, const char* service);
 
-    virtual bool updateLog(const char* option, IEspContext& espContext, IPropertyTree* userContext, IPropertyTree* userRequest,
-        const char* backEndResp, const char* userResp, const char* logDatasets, StringBuffer& status);
-    virtual bool updateLog(IEspContext& espContext, const char* option, const char* logContent, StringBuffer& status);
-    virtual bool updateLog(IEspContext& espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp);
+    virtual IEspLogEntry* createLogEntry();
+    virtual bool updateLog(IEspContext* espContext, IEspUpdateLogRequestWrap& req, IEspUpdateLogResponse& resp);
+    virtual bool updateLog(IEspLogEntry* entry, StringBuffer& status);
     virtual bool getTransactionSeed(StringBuffer& transactionSeed, StringBuffer& status);
     virtual bool getTransactionSeed(IEspGetTransactionSeedRequest& req, IEspGetTransactionSeedResponse& resp);
     virtual bool getTransactionID(StringAttrMapping* transFields, StringBuffer& transactionID, StringBuffer& status);

esp/logging/test/logging_test.cpp

@@ -137,7 +137,16 @@ void sendRequest()
         printf("backEndResp: <%s>.\n", backEndResp);
 
         Sleep(5000); //Waiting for loggingManager to start
-        loggingManager->updateLog(option.str(), *espContext, userContextTree, userRequestTree, backEndResp, userRespXML.str(), logDatasetsXML.str(), status);
+        Owned<IEspLogEntry> entry = loggingManager->createLogEntry();
+        entry->setOption(option.str());
+        entry->setEspContext(espContext);
+        entry->setUserContextTree(userContextTree);
+        entry->setUserRequestTree(userRequestTree);
+        entry->setUserResp(userRespXML.str());
+        entry->setBackEndResp(backEndResp);
+        entry->setLogDatasets(logDatasetsXML.str());
+
+        loggingManager->updateLog(entry, status);
     }
     else if (action.length() && strieq(action.str(), "UpdateLog1"))
     {
@@ -157,7 +166,12 @@ void sendRequest()
         short servPort = logContentTree->getPropInt("ESPContext/Port");
         espContext->setUserID(userName);
         espContext->setServAddress(sourceIP, servPort);
-        loggingManager->updateLog(*espContext, option.str(), logContentXML.str(), status);
+
+        Owned<IEspLogEntry> entry = loggingManager->createLogEntry();
+        entry->setOption(option.str());
+        entry->setEspContext(espContext);
+        entry->setLogContent(logContentXML.str());
+        loggingManager->updateLog(entry, status);
     }
     else
         printf("Invalid action.\n");

esp/services/esdl_svc_engine/esdl_binding.cpp

@@ -662,8 +662,17 @@ bool EsdlServiceImpl::handleResultLogging(IEspContext &espcontext, IPropertyTree
     bool success = true;
     if (m_oLoggingManager)
     {
+        Owned<IEspLogEntry> entry = m_oLoggingManager->createLogEntry();
+        entry->setOption(LOGGINGDBSINGLEINSERT);
+        entry->setEspContext(&espcontext);
+        entry->setUserContextTree(reqcontext);
+        entry->setUserRequestTree(request);
+        entry->setUserResp(finalresp);
+        entry->setBackEndResp(rawresp);
+        entry->setLogDatasets(logdata);
+
         StringBuffer logresp;
-        success = m_oLoggingManager->updateLog(LOGGINGDBSINGLEINSERT, espcontext, reqcontext, request, rawresp, finalresp, logdata, logresp);
+        success = m_oLoggingManager->updateLog(entry, logresp);
         ESPLOG(LogMin,"ESDLService: Attempted to log ESP transaction: %s", logresp.str());
     }