public async Task Execute(string messageId, string messageBody)
        {
            this._logger.LogInformation(
                $"{nameof(DataRequestSubscriber)} about to process a message with id of {messageId}");

            var opCtx = this._systemProcessContext.CreateAndStartOperationContext();
            ISystemProcessOperationThirdPartyDataRequestContext dataCtx = null;

            try
            {
                var request = this._serialiser.Deserialise(messageBody);
                dataCtx = opCtx.CreateAndStartDataRequestContext(messageId, request.SystemProcessOperationId);

                if (!this.ValidateDataRequest(request.SystemProcessOperationId))
                {
                    this._logger.LogError(
                        $"{nameof(DataRequestSubscriber)} received a null or empty system process operation id. Exiting");
                    return;
                }

                await this._dataRequestManager.Handle(request.SystemProcessOperationId, dataCtx);
            }
            catch (Exception e)
            {
                dataCtx?.EventError(e.Message);
            }
            finally
            {
                dataCtx?.EndEvent();
                opCtx.EndEvent();

                this._logger.LogInformation(
                    $"{nameof(DataRequestSubscriber)} completed processing a message with id of {messageId}");
            }
        }
        public async Task Handle(
            string systemProcessOperationId,
            ISystemProcessOperationThirdPartyDataRequestContext dataRequestContext)
        {
            if (string.IsNullOrWhiteSpace(systemProcessOperationId))
            {
                this._logger.LogError(
                    $"{nameof(DataRequestManager)} asked to handle a systemProcessOperationId that had a null or empty id");
                dataRequestContext.EventError("DataRequestManager systemProcessOperationId was null");
                return;
            }

            this._logger.LogInformation(
                $"{nameof(DataRequestManager)} handling request with id {systemProcessOperationId}");

            var dataRequests =
                await this._dataRequestRepository.DataRequestsForSystemOperation(systemProcessOperationId);

            dataRequests = dataRequests ?? new List <MarketDataRequest>();
            this._logger.LogInformation(
                $"handling request with id {systemProcessOperationId} had {dataRequests.Count} data requests to process across all data sources");

            try
            {
                // Equity handling
                var factsetData = dataRequests.Where(
                    _ => _.DataSource == DataSource.Factset || _.DataSource == DataSource.Any ||
                    _.DataSource == DataSource.AnyInterday).ToList();
                this._logger.LogInformation(
                    $"handling request with id {systemProcessOperationId} had {factsetData.Count} factset data requests to process");
                if (factsetData.Any())
                {
                    await this._factsetSynchroniser.Handle(systemProcessOperationId, dataRequestContext, factsetData);
                }

                var bmllData = dataRequests.Where(
                    _ => _.DataSource == DataSource.Bmll || _.DataSource == DataSource.Any ||
                    _.DataSource == DataSource.AnyIntraday).ToList();
                this._logger.LogInformation(
                    $"handling request with id {systemProcessOperationId} had {bmllData.Count} bmll data requests to process");
                if (bmllData.Any())
                {
                    await this._bmllSynchroniser.Handle(systemProcessOperationId, dataRequestContext, bmllData);
                }

                // Fixed income handling
                var refinitivInterdayData = dataRequests.Where(_ => _.DataSource == DataSource.RefinitivInterday).ToList();

                this._logger.LogInformation($"handling request with id {systemProcessOperationId} had {refinitivInterdayData.Count} refinitiv data requests to process");

                if (refinitivInterdayData.Any())
                {
                    await this._refinitivDataSynchroniser.Handle(systemProcessOperationId, dataRequestContext, refinitivInterdayData);
                }

                var markitData = dataRequests.Where(
                    _ => _.DataSource == DataSource.Markit || _.DataSource == DataSource.Any ||
                    _.DataSource == DataSource.AnyInterday ||
                    _.DataSource == DataSource.AnyIntraday).ToList();
                this._logger.LogInformation(
                    $"handling request with id {systemProcessOperationId} had {markitData.Count} markit data requests to process");
                if (markitData.Any())
                {
                    await this._markitSynchroniser.Handle(systemProcessOperationId, dataRequestContext, markitData);
                }
            }
            finally
            {
                if (dataRequests != null && dataRequests.Any())
                {
                    await this._rulePublisher.RescheduleRuleRun(systemProcessOperationId, dataRequests);
                }

                this._logger.LogInformation(
                    $"{nameof(DataRequestManager)} completed handling request with id {systemProcessOperationId}");
            }
        }