private static void PublishRecoverEvent(string msg)
{
if (Interlocked.CompareExchange(ref RegionTagRetriever.isGlsOk, 1, 0) == 0)
{
EventNotificationItem.Publish(ExchangeComponent.MessageTracing.Name, "RegionTagNonUrgent", null, msg, ResultSeverityLevel.Informational, false);
}
}
private static void RaiseAlertIfHealthStateChange(ref int state, string monitorName, string error)
{
if (Interlocked.CompareExchange(ref state, 1, 0) == 0)
{
EventNotificationItem.Publish(ExchangeComponent.Name, monitorName, null, error, ResultSeverityLevel.Error, false);
}
}
public static void ReadConfiguration()
{
string fileLocation = "d:\\MessageTracingServiceLogs";
ServiceLogger.ServiceLogLevel = ServiceLogger.LogLevel.Error;
ServiceLogger.MaximumLogAge = TimeSpan.Parse("5.00:00:00");
ServiceLogger.MaximumLogDirectorySize = 500000000L;
ServiceLogger.MaximumLogFileSize = 5000000L;
try
{
fileLocation = ConfigurationManager.AppSettings["LogFilePath"].Trim();
ServiceLogger.ServiceLogLevel = (ServiceLogger.LogLevel)Convert.ToInt32(ConfigurationManager.AppSettings["LogLevel"]);
ServiceLogger.MaximumLogAge = TimeSpan.Parse(ConfigurationManager.AppSettings["LogFileMaximumLogAge"]);
ServiceLogger.MaximumLogDirectorySize = Convert.ToInt64(ConfigurationManager.AppSettings["LogFileMaximumLogDirectorySize"]);
ServiceLogger.MaximumLogFileSize = Convert.ToInt64(ConfigurationManager.AppSettings["LogFileMaximumLogFileSize"]);
}
catch (Exception ex)
{
string text = string.Format("Fail to read config value, default values are used. The error is {0}", ex.ToString());
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_ConfigSettingNotFound, Thread.CurrentThread.Name, new object[]
{
text
});
EventNotificationItem.Publish(ExchangeComponent.Name, "BadServiceLoggerConfig", null, text, ResultSeverityLevel.Error, false);
if (RetryHelper.IsSystemFatal(ex))
{
throw;
}
}
finally
{
ServiceLogger.FileLocation = fileLocation;
}
}
public void WriteDuplicateRuleIdAcrossRulePacksDiagnosticsInformation(int traceSourceHashCode, OrganizationId currentOrganizationId, string offendingRulePackageObjectDn1, string offendingRulePackageObjectDn2, string duplicateRuleId)
{
string organizationId = currentOrganizationId.ToString();
Task.Factory.StartNew(delegate()
{
ExManagementApplicationLogger.LogEvent(ManagementEventLogConstants.Tuple_DuplicateDataClassificationIdAcrossRulePack, new string[]
{
organizationId,
duplicateRuleId,
offendingRulePackageObjectDn1,
offendingRulePackageObjectDn2
});
});
string eventMessage = string.Format("A duplicate data classification identifier '{1}' has been identified in objects with DN '{2}' and '{3}' under organization '{0}'.", new object[]
{
organizationId,
duplicateRuleId,
offendingRulePackageObjectDn1,
offendingRulePackageObjectDn2
});
Task.Factory.StartNew(delegate()
{
EventNotificationItem.Publish(ClassificationDefinitionsDiagnosticsReporter.ServiceName, "ClassificationManagement", "NonUniqueDataClassificationIdentifierFound", eventMessage, ResultSeverityLevel.Warning, false);
});
this.dlpTracer.TraceError((long)traceSourceHashCode, eventMessage);
}
protected void PublishMonitoringResult()
{
string name = ExchangeComponent.SiteMailbox.Name;
string name2 = base.GetType().Name;
string notificationReason = this.siteUri.AbsoluteUri.Replace('/', '\\');
ResultSeverityLevel severity = ResultSeverityLevel.Informational;
string message = string.Empty;
if (this.LastError != null)
{
severity = ResultSeverityLevel.Error;
message = this.LastError.Message;
}
EventNotificationItem eventNotificationItem = new EventNotificationItem(name, name2, notificationReason, severity);
eventNotificationItem.Message = message;
try
{
eventNotificationItem.Publish(false);
}
catch (UnauthorizedAccessException exception)
{
ProtocolLog.LogError(ProtocolLog.Component.Monitor, this.loggingContext, "PublishMonitoringResult failed with UnauthorizedAccessException", exception);
}
catch (EventLogNotFoundException exception2)
{
ProtocolLog.LogError(ProtocolLog.Component.Monitor, this.loggingContext, "PublishMonitoringResult failed with EventLogNotFoundException", exception2);
}
}
public static void PublishMonitoringEventNotification(string serviceName, string component, string message, ResultSeverityLevel severity)
{
if (Globals.IsPreCheckinApp)
{
return;
}
if (component == Feature.InstantMessage.ToString())
{
if (severity == ResultSeverityLevel.Error || severity == ResultSeverityLevel.Critical)
{
ExTraceGlobals.InstantMessagingTracer.TraceError(0L, message);
}
else if (severity == ResultSeverityLevel.Warning)
{
ExTraceGlobals.InstantMessagingTracer.TraceWarning(0L, message);
}
else
{
ExTraceGlobals.InstantMessagingTracer.TraceInformation(0, 0L, message);
}
}
EventNotificationItem eventNotificationItem = new EventNotificationItem(serviceName, component, null, message, severity);
eventNotificationItem.Publish(false);
}
private static void PublishErrorEvent(string errMsg)
{
if (!errMsg.Contains("ProtocolError"))
{
EventNotificationItem.Publish(ExchangeComponent.FfoUmc.Name, EOPRecipient.PswsFailureMonitor, null, errMsg, ResultSeverityLevel.Error, false);
}
}
protected void PublishMonitoringResult(int numberofAttemptsAfterLastSuccess, ExDateTime firstFailedSyncTimeAfterLastSuccess, ExDateTime lastFailedSyncTime)
{
TimeSpan t = lastFailedSyncTime - firstFailedSyncTimeAfterLastSuccess;
if (numberofAttemptsAfterLastSuccess >= FolderTaskLogger.MinNumberOfFailedSyncAttemptsForAlert && t >= FolderTaskLogger.MinDurationOfSyncFailureForAlert)
{
string name = ExchangeComponent.PublicFolders.Name;
string component = "PublicFolderMailboxSync";
string empty = string.Empty;
EventNotificationItem eventNotificationItem = new EventNotificationItem(name, component, empty, ResultSeverityLevel.Error);
eventNotificationItem.StateAttribute1 = this.storeSession.MailboxGuid.ToString();
eventNotificationItem.StateAttribute2 = this.storeSession.MdbGuid.ToString();
eventNotificationItem.StateAttribute3 = ((this.storeSession.OrganizationId != null && this.storeSession.OrganizationId.OrganizationalUnit != null) ? this.storeSession.OrganizationId.OrganizationalUnit.Name.ToString() : string.Empty);
if (this.LastError == null)
{
eventNotificationItem.Message = "No LastError but failing for at least this long: " + FolderTaskLogger.MinDurationOfSyncFailureForAlert;
}
else
{
eventNotificationItem.Message = FolderTaskLoggerBase.GetExceptionLogString(this.LastError, FolderTaskLoggerBase.ExceptionLogOption.All);
}
try
{
eventNotificationItem.Publish(false);
}
catch (UnauthorizedAccessException exception)
{
this.LogEvent(LogEventType.Warning, string.Format("PublishMonitoringResult: Failed with exception {0}", FolderTaskLoggerBase.GetExceptionLogString(exception, FolderTaskLoggerBase.ExceptionLogOption.All)));
}
catch (EventLogNotFoundException exception2)
{
this.LogEvent(LogEventType.Warning, string.Format("PublishMonitoringResult: Failed with exception {0}", FolderTaskLoggerBase.GetExceptionLogString(exception2, FolderTaskLoggerBase.ExceptionLogOption.All)));
}
}
}
private static SharepointValidator Create(IConfigurationSession configurationSession, ADObjectId executingUserId, Task.TaskErrorLoggingDelegate writeErrorDelegate, Action <LocalizedString> writeWarningDelegate, Func <LocalizedString, bool> shouldContinueDelegate, string logTag, SourceValidator.Clients client, int existingSitesCount, ExecutionLog logger)
{
ArgumentValidator.ThrowIfNull("configurationSession", configurationSession);
Uri uri = null;
Uri uri2 = null;
OrganizationId organizationId = configurationSession.GetOrgContainer().OrganizationId;
UnifiedPolicyConfiguration.GetInstance().GetTenantSharePointUrls(configurationSession, out uri, out uri2);
if (uri == null)
{
EventNotificationItem.Publish(ExchangeComponent.UnifiedComplianceSourceValidation.Name, "SharepointValidatorUnexpectedError", client.ToString(), string.Format("Tenant {0}, Error:{1}", organizationId.ToExternalDirectoryOrganizationId(), Strings.FailedToGetSpSiteUrlForTenant), ResultSeverityLevel.Error, false);
throw new SpValidatorException(Strings.FailedToGetSpSiteUrlForTenant);
}
ADUser actAsUser = null;
if (executingUserId != null)
{
ADSessionSettings sessionSettings = ADSessionSettings.FromExternalDirectoryOrganizationId(new Guid(organizationId.ToExternalDirectoryOrganizationId()));
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, sessionSettings, 520, "Create", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\transport\\UnifiedPolicy\\Validators\\SharepointValidator.cs");
actAsUser = tenantOrRootOrgRecipientSession.FindADUserByObjectId(executingUserId);
}
ICredentials credentials = UnifiedPolicyConfiguration.GetInstance().GetCredentials(configurationSession, actAsUser);
if (credentials == null)
{
EventNotificationItem.Publish(ExchangeComponent.UnifiedComplianceSourceValidation.Name, "SharepointValidatorUnexpectedError", client.ToString(), string.Format("Tenant {0}, Error:{1}", organizationId.ToExternalDirectoryOrganizationId(), Strings.FailedToGetCredentialsForTenant), ResultSeverityLevel.Error, false);
throw new SpValidatorException(Strings.FailedToGetCredentialsForTenant);
}
int maxLimitFromConfig = SourceValidator.GetMaxLimitFromConfig("MaxSitesLimit", 100, existingSitesCount);
return(new SharepointValidator(uri, credentials, executingUserId != null, writeErrorDelegate, writeWarningDelegate, shouldContinueDelegate, maxLimitFromConfig, logger, logTag, organizationId.ToExternalDirectoryOrganizationId(), client));
}
private void PublishErrorEvent(string error)
{
if (Interlocked.CompareExchange(ref RegionTagRetriever.isGlsOk, 0, 1) == 1)
{
EventNotificationItem.Publish(ExchangeComponent.MessageTracing.Name, "RegionTagNonUrgent", null, string.Format("{0}\nThe caller id is {1}", error, this.glsCallerId.CallerIdString), ResultSeverityLevel.Error, false);
}
}
internal void SetHealthGreen(string monitor, string msg)
{
FaultInjection.FaultInjectionTracer.TraceTest(39836U);
this.Checkpoint(msg);
this.Trace(SystemProbe.Status.Pass, string.Empty);
EventNotificationItem.Publish(this.ComponentName, monitor, null, msg, ResultSeverityLevel.Informational, false);
}
public void PublishEvent(string componentName, string organization, string context, Exception exception)
{
ArgumentValidator.ThrowIfNullOrEmpty("componentName", componentName);
ArgumentValidator.ThrowIfNullOrEmpty("organization", organization);
string arg = (exception != null) ? exception.ToString() : "<>";
EventNotificationItem.Publish(ExchangeComponent.UnifiedPolicy.Name, componentName, null, string.Format("Policy sync issues identified for Tenant {0}.\r\nContext: {1}.\r\nError: {2}.", organization, context, arg), ResultSeverityLevel.Error, false);
}
public static void LogCorruptDataIgnored(Type queryType, Exception exception)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_WebstoreDataProviderCorruptDataIgnored, new object[]
{
queryType.Name,
exception
});
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "WebstoreDataProvider.CorruptDataIgnored", null, string.Format("The Webstore Data Provider ignored corrupt data processing a query for {0} that triggered the following exception: {1}", queryType.Name, exception), ResultSeverityLevel.Error, false);
}
public static void LogBloomFilterDataProviderFailureLoadingFile(Type dataType, Exception ex)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_BloomFilterDataProviderFailureLoadingFile, new object[]
{
dataType.Name,
ex
});
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "CompositeDataProvider.ErrorLoadingNewBloomFile", null, string.Format("The CompositeDataProvider encountered an error swapping to a new {0} bloom filter file: {1}", dataType.Name, ex), ResultSeverityLevel.Error, false);
}
public static void LogStaleTracerTokenDetected(Type dataType, string expectedTracer)
{
EventLogger.LogPeriodicEvent(FfoHygineDataProviderEventLogConstants.Tuple_BloomFilterDataProviderStaleTracerTokenDetected, dataType.Name + expectedTracer, new object[]
{
dataType.Name,
expectedTracer
});
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "CompositeDataProvider.StaleTracerTokenDetected", null, string.Format("The CompositeDataProvider encountered a stale tracer token in the {0} bloom filter file. Expected to find key '{1}'.", dataType.Name, expectedTracer), ResultSeverityLevel.Error, false);
}
public static void LogInMemoryCacheFatalErrorEncounteredDuringPriming(string cache, Exception fatalError)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_InMemoryCachePrimingComplete, new object[]
{
cache,
fatalError
});
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "InMemoryCache.FatalErrorDuringPriming", null, string.Format("The in-memory cache for {0} data encountered a fatal error during priming of tenant data: {1}", cache, fatalError), ResultSeverityLevel.Error, false);
}
// Token: 0x06001305 RID: 4869 RVA: 0x0004CEEC File Offset: 0x0004B0EC
public void RaiseRedEvent(string failureMsg)
{
if (ExDateTime.Now - this.lastRedEventRaisedTime > this.maxRedFreq || this.lastGreenEventRaisedTime > this.lastRedEventRaisedTime)
{
string text = string.Format("ADHealthReporter: AD access is failing: {0}", failureMsg);
EventNotificationItem eventNotificationItem = new EventNotificationItem("MSExchangeRepl", "MonitoringADConfigManager", "ADConfigQueryStatus", text, text, ResultSeverityLevel.Critical);
eventNotificationItem.Publish(false);
this.lastRedEventRaisedTime = ExDateTime.Now;
}
}
public static void LogCompositeDataProviderCacheUnhealthy(string cacheName)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_CompositeDataProviderCacheUnhealthy, new object[]
{
cacheName
});
string notificationReason = string.Format("The Cache Data Provider determined priming info to be unhealthy for type {0}.", cacheName);
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "FfoCacheDataProvider.GetPrimingInfoUnhealthy", null, notificationReason, ResultSeverityLevel.Error, false);
}
public static void LogInMemoryCacheFatalErrorEncounteredDuringRefresh(string cache, object itemKey, Exception fatalError)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_InMemoryCacheFatalErrorEncounteredDuringRefresh, new object[]
{
cache,
itemKey,
fatalError
});
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "InMemoryCache.FatalErrorDuringRefresh", null, string.Format("The in-memory cache for {0} data encountered a fatal error during refresh of the item with key {1}: {2}", cache, itemKey, fatalError), ResultSeverityLevel.Error, false);
}
public static void LogNoConnectionAvailException(Exception exception)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_WebstoreDataProviderConnectionError, new object[]
{
exception
});
string notificationReason = string.Format("The Webstore Data provider is encountered a no connection exception and failing over to the database in other Datacenter: {0}.", exception);
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "FfoWebstoreDataProvider.CrossDatacenterFailover", null, notificationReason, ResultSeverityLevel.Error, false);
}
public void Notify(EventNotificationEntry entry, EventNotificationPropertyBag propertyBag)
{
if (entry == 4)
{
string text = (propertyBag != null) ? propertyBag.ObjectGuid : string.Empty;
StorageGlobals.EventLogger.LogEvent(this.clientContext.OrgId, StorageEventLogConstants.Tuple_UnknownTemplateInPublishingLicense, text, text);
string notificationReason = string.Format("Exchange could not match the RMS template with Id {0} specified in the publishing license against templates configured for this tenant.", text);
EventNotificationItem.Publish(ExchangeComponent.Rms.Name, "UnknownTemplateInPublishingLicense", null, notificationReason, ResultSeverityLevel.Warning, false);
}
}
// Token: 0x0600000B RID: 11 RVA: 0x000027EC File Offset: 0x000009EC
private static void PublishServiceStartFailureNotification(string exceptionMessage = null)
{
string text = "Mailbox Transport Delivery service did not successfully initialize.";
if (!string.IsNullOrEmpty(exceptionMessage))
{
text += string.Format(" Exception was: {0}", exceptionMessage);
}
EventNotificationItem.Publish(ExchangeComponent.MailboxTransport.Name, "DeliveryServiceStartFailure", null, text, ResultSeverityLevel.Warning, false);
}
// Token: 0x06001306 RID: 4870 RVA: 0x0004CF60 File Offset: 0x0004B160
public void RaiseGreenEvent()
{
if (ExDateTime.Now - this.lastGreenEventRaisedTime > this.maxGreenFreq)
{
string text = "ADHealthReporter: AD access is healthy.";
EventNotificationItem eventNotificationItem = new EventNotificationItem("MSExchangeRepl", "MonitoringADConfigManager", "ADConfigQueryStatus", text, text, ResultSeverityLevel.Informational);
eventNotificationItem.Publish(false);
this.lastGreenEventRaisedTime = ExDateTime.Now;
}
}
internal LogFileRange ProcessOneWatermark(string line)
{
ArgumentValidator.ThrowIfNull("line", line);
try
{
string fileRangeFromWatermark = WatermarkFile.GetFileRangeFromWatermark(line);
LogFileRange logFileRange = LogFileRange.Parse(fileRangeFromWatermark);
logFileRange.ProcessingStatus = ProcessingStatus.CompletedProcessing;
lock (this.blocksProcessedLock)
{
if (!this.blocksProcessed.ContainsKey(logFileRange.StartOffset))
{
this.AddRangeToProcessed(logFileRange);
return(logFileRange);
}
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_OverlappingLogRangeInWatermarkFile, this.WatermarkFileFullName, new object[]
{
this.WatermarkFileFullName,
logFileRange.StartOffset,
logFileRange.EndOffset,
logFileRange.StartOffset,
this.blocksProcessed[logFileRange.StartOffset].EndOffset
});
string text = string.Format("There are overlapping log ranges in watermark file {0}: ({1}, {2}), ({3}, {4}).", new object[]
{
this.WatermarkFileFullName,
logFileRange.StartOffset,
logFileRange.EndOffset,
logFileRange.StartOffset,
this.blocksProcessed[logFileRange.StartOffset].EndOffset
});
if (Interlocked.CompareExchange(ref WatermarkFile.overlappingWatermarksInWatermarkFile, 1, 0) == 0)
{
EventNotificationItem.Publish(ExchangeComponent.Name, "OverlappingWatermarkRecordsInFile", null, text, ResultSeverityLevel.Error, false);
}
ServiceLogger.LogError(ServiceLogger.Component.WatermarkFile, (LogUploaderEventLogConstants.Message) 3221231476U, text, this.instance, this.WatermarkFileFullName);
}
}
catch (MalformedLogRangeLineException ex)
{
string text2 = string.Format("Failed to parse watermark from {0}: {1}", this.watermarkFullFileName, ex.Message);
ExTraceGlobals.ReaderTracer.TraceError((long)this.GetHashCode(), text2);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_WatermarkFileParseException, this.watermarkFullFileName, new object[]
{
this.watermarkFullFileName,
ex.Message
});
if (Interlocked.CompareExchange(ref WatermarkFile.watermarkParseError, 1, 0) == 0)
{
EventNotificationItem.Publish(ExchangeComponent.Name, "MalformedWatermarkRecordError", null, text2, ResultSeverityLevel.Warning, false);
}
ServiceLogger.LogError(ServiceLogger.Component.WatermarkFile, (LogUploaderEventLogConstants.Message) 3221231475U, ex.Message, this.instance, this.watermarkFullFileName);
}
return(null);
}
public static void LogCacheDataProviderGetPrimingInfoFailure(string cacheName, Exception exception)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_CacheDataProviderGetPrimingInfoFailure, new object[]
{
cacheName,
exception
});
string notificationReason = string.Format("The Cache Data Provider unable to determine priming info for type {0}. Error: {1}.", cacheName, exception);
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "FfoCacheDataProvider.GetPrimingInfoFailure", null, notificationReason, ResultSeverityLevel.Error, false);
}
// Token: 0x06000010 RID: 16 RVA: 0x00002574 File Offset: 0x00000774
private static void LogCreateDirectoryFailedEvent(string absolutePath, string exceptionMessage)
{
LogSearchService.Logger.LogEvent(MSExchangeTransportLogSearchEventLogConstants.Tuple_LogSearchServiceCreateDirectoryFailed, null, new object[]
{
absolutePath,
exceptionMessage
});
string notificationReason = string.Format("The Microsoft Exchange Transport Log Search service failed to create message tracking log directory: {0} because of error: {1}", absolutePath, exceptionMessage);
EventNotificationItem.Publish(ExchangeComponent.Transport.Name, "TransportLogSearch", null, notificationReason, ResultSeverityLevel.Warning, false);
}
public static void LogPartitionMapDatabaseReadError(Exception ex, string localFileName)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_ErrorReadingPartitionMapFromDB, new object[]
{
ex.ToString(),
localFileName
});
string notificationReason = string.Format("Error {0} reading Partition Map from DB. Reading Partition Map from Local File {1}", ex, localFileName);
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "FfoWebstoreDataProvider.PartitionMapDBRead", null, notificationReason, ResultSeverityLevel.Error, false);
}
public static void LogPolicySyncWebserviceGlsError(string operation, Workload workload, string objectType, SyncCallerContext callerContext, Exception exception)
{
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "PolicySyncWS.GlsError", null, string.Format("The PolicySync Webservice encountered a Gls error (operation: {0}, workload: {1}, type: {2}, context: {3}): {4}", new object[]
{
operation,
workload,
objectType,
callerContext,
exception
}), ResultSeverityLevel.Error, false);
}
public static void LogCacheProviderUnhandledException(string cacheName, Exception exception)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_CacheDataProviderCallFailure, new object[]
{
exception,
cacheName
});
string notificationReason = string.Format("The Cache Data Provider fatally failed for cache {1} with error: {0}.", exception, cacheName);
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "FfoCacheDataProvider.UnhandledException", null, notificationReason, ResultSeverityLevel.Error, false);
}
public static void LogCompositeDataProviderCacheFailover(string objectType, Exception exception)
{
EventLogger.LogEvent(FfoHygineDataProviderEventLogConstants.Tuple_CompositeDataProviderCacheFailover, new object[]
{
objectType,
exception
});
string notificationReason = string.Format("The Composite Data provider is encountered a permanent DAL exception and failing over to the Cache for type {0}: {1}.", objectType, exception);
EventNotificationItem.Publish(ExchangeComponent.Dal.Name, "FfoCacheDataProvider.CacheFailover", null, notificationReason, ResultSeverityLevel.Error, false);
}