void CxpsTelemetryLogger::AddRequestDataToTelemetryLogger()

in host/cxpslib/Telemetry/cxpstelemetrylogger.cpp [435:622]
149 lines of code
34 McCabe index (conditional complexity)

    void CxpsTelemetryLogger::AddRequestDataToTelemetryLogger(const RequestTelemetryData &reqTelData)
    {
        try
        {
            if (reqTelData.m_dataError != ReqTelErr_None)
            {
                // No data in here could be trusted.

                // TODO-SanKumar-1711: We could probably trial and error by testing values and see
                // if anything could be salvaged out of this. (For ex, although we called out there's
                // error in telemetry data, host id isn't affected in the current workflow).

                // TODO-SanKumar-1711: Should we add this data to SourceGeneral telemetry, so we get
                // the type of file (or) at least the failing host for easier debugging? (The data
                // representation will get complex).

                GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportRequestTelemetryDataError, reqTelData.m_dataError);
                return;
            }

            std::string parsedHostId;
            std::string parsedDevice;
            std::string parsedFileName;
            RequestTelemetryDataLevel dataLevel = reqTelData.m_dataLevel;
            FileType retrievedFileType = FileType_Invalid;

            if (dataLevel == ReqTelLevel_File)
            {
                if (reqTelData.m_filePath.empty())
                {
                    BOOST_ASSERT(false);
                    retrievedFileType = FileType_Invalid;
                    dataLevel = ReqTelLevel_Session; // Fallback to session level logging
                }
                else
                {
                    // Trusting the parsed host id instead of the session advertised host id,
                    // while uploading source file telemetries.
                    if (CS_MODE_RCM == GetCSMode())
                    {
                        retrievedFileType = SourceFilePathParser::GetCxpsFileTypeInRcmMode(
                            reqTelData.m_filePath, parsedHostId, parsedDevice, parsedFileName);
                    }
                    else
                    {
                        retrievedFileType = SourceFilePathParser::GetCxpsFileType(
                            reqTelData.m_filePath, parsedHostId, parsedDevice, parsedFileName);
                    }

                    switch (retrievedFileType)
                    {
                    case FileType_DiffSync:
                    {
                        if (parsedHostId.empty() || parsedDevice.empty() || parsedFileName.empty())
                        {
                            BOOST_ASSERT(false);
                            GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_DiffEmptyMeta);
                            return;
                        }

                        BOOST_ASSERT(parsedHostId == reqTelData.m_hostId);

                        DiffSyncFileMetadata diffFileMetadata;
                        SourceFilePathParser::ParseDiffSyncFileName(parsedFileName, diffFileMetadata);

                        SourceDiffTelemetryRowPtr sourceDiffRow =
                            m_hostTelemetryMap.GetValidSourceDiffTelemetry(parsedHostId, parsedDevice);
                        if (!sourceDiffRow)
                        {
                            GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_Alloc);
                            return;
                        }

                        if (!sourceDiffRow->AddToTelemetry(reqTelData.m_requestType, reqTelData, diffFileMetadata))
                        {
                            GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_AddToDiffTel);
                            return;
                        }

                        return; // Successfully added the telemetry
                    }
                    case FileType_Resync:
                    {
                        if (parsedHostId.empty() || parsedDevice.empty() || parsedFileName.empty())
                        {
                            BOOST_ASSERT(false);
                            GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_ResyncEmptyMeta);
                            return;
                        }

                        BOOST_ASSERT(parsedHostId == reqTelData.m_hostId);

                        ResyncFileMetadata resyncFileMetadata;
                        SourceFilePathParser::ParseResyncFileName(parsedFileName, resyncFileMetadata);

                        SourceResyncTelemetryRowPtr sourceResyncRow =
                            m_hostTelemetryMap.GetValidSourceResyncTelemetry(parsedHostId, parsedDevice);
                        if (!sourceResyncRow)
                        {
                            GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_Alloc);
                            return;
                        }

                        if (!sourceResyncRow->AddToTelemetry(reqTelData.m_requestType, reqTelData, resyncFileMetadata))
                        {
                            GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_AddToResyncTel);
                            return;
                        }

                        return; // Successfully added the telemetry
                    }
                    case FileType_Log:
                    case FileType_Telemetry:
                    case FileType_ChurStat:
                    case FileType_ThrpStat:
                    case FileType_TstData:
                    case FileType_Unknown:
                    case FileType_Invalid:
                    case FileType_InternalErr:
                        dataLevel = ReqTelLevel_Session; // Fallback to session level logging for these types
                        break;

                    default:
                        BOOST_ASSERT(false);
                        GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_AddTelUnknFType);
                        return;
                    }
                }
            }

            if (dataLevel == ReqTelLevel_Session)
            {
                // Prefer parsedHostId, if empty, use the host id provided at login.
                const std::string &sessionHostId = !parsedHostId.empty() ? parsedHostId : reqTelData.m_hostId;

                if (sessionHostId.empty())
                {
                    BOOST_ASSERT(false);
                    GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_SrcGenEmptyMeta);
                    return;
                }

                SourceGeneralTelemetryRowPtr sourceGenPtr =
                    m_hostTelemetryMap.GetValidSourceGeneralTelemetry(sessionHostId);

                if (!sourceGenPtr)
                {
                    GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_Alloc);
                    return;
                }

                if (!sourceGenPtr->AddToTelemetry(retrievedFileType, reqTelData.m_requestType, reqTelData))
                {
                    GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_AddToSrcGenTel);
                    return;
                }

                return; // Successfully added the telemetry
            }

            if (dataLevel == ReqTelLevel_Server)
            {
                // Currently, all server level telemetry can come only on failures (like, not logged in).
                BOOST_ASSERT(!reqTelData.m_hasRespondedSuccess && reqTelData.m_requestFailure != RequestFailure_Success);

                GlobalCxpsTelemetryRowPtr globTelPtr = GetValidGlobalTelemetry();
                if (!globTelPtr)
                {
                    GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_Alloc);
                    return;
                }

                if (!globTelPtr->AddToTelemetry(reqTelData))
                {
                    GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_AddToGlobalTel);
                    return;
                }

                return; // Successfully added the telemetry
            }

            BOOST_ASSERT(false); // Shouldn't reach here!
            GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_AddTelReachedEof);
            return;
        }
        GENERIC_CATCH_LOG_ACTION("AddRequestDataToTelemetryLogger",
            GLOBAL_TEL_REPORT_ERR_N_LASPSE_SEQ_NUM(ReportTelemetryFailure, TelFailure_AddToTelUnknErr));
    }