public CircuitBreaker(ICommandConfigSet configSet, ICommandMetrics metrics) { this.ConfigSet = configSet; this.Metrics = metrics; this.OpenFlag = new AtomicBoolean(); this.CircuitOpenedOrLastTestedTime = new AtomicLong(); }
protected virtual void Config(ICommandConfigSet configSet) { if (this._config != null) { this._config(configSet); } }
public static bool AreEqual(ICommandConfigSet configSet1, ICommandConfigSet configSet2) { if (configSet1 == configSet2) { return(true); } if (configSet1 == null || configSet2 == null) { return(false); } return(configSet1.CircuitBreakerEnabled == configSet2.CircuitBreakerEnabled && configSet1.CircuitBreakerErrorThresholdPercentage == configSet2.CircuitBreakerErrorThresholdPercentage && configSet1.CircuitBreakerForceClosed == configSet2.CircuitBreakerForceClosed && configSet1.CircuitBreakerForceOpen == configSet2.CircuitBreakerForceOpen && configSet1.CircuitBreakerRequestCountThreshold == configSet2.CircuitBreakerRequestCountThreshold && configSet1.CircuitBreakerSleepWindowInMilliseconds == configSet2.CircuitBreakerSleepWindowInMilliseconds && configSet1.CommandMaxConcurrentCount == configSet2.CommandMaxConcurrentCount && configSet1.CommandTimeoutInMilliseconds == configSet2.CommandTimeoutInMilliseconds && configSet1.DegradeLogLevel == configSet2.DegradeLogLevel && configSet1.FallbackMaxConcurrentCount == configSet2.FallbackMaxConcurrentCount && configSet1.LogExecutionError == configSet2.LogExecutionError && configSet1.MaxAsyncCommandExceedPercentage == configSet2.MaxAsyncCommandExceedPercentage && configSet1.MetricsHealthSnapshotIntervalInMilliseconds == configSet2.MetricsHealthSnapshotIntervalInMilliseconds && configSet1.MetricsRollingPercentileBucketSize == configSet2.MetricsRollingPercentileBucketSize && configSet1.MetricsRollingPercentileEnabled == configSet2.MetricsRollingPercentileEnabled && configSet1.MetricsRollingPercentileWindowBuckets == configSet2.MetricsRollingPercentileWindowBuckets && configSet1.MetricsRollingPercentileWindowInMilliseconds == configSet2.MetricsRollingPercentileWindowInMilliseconds && configSet1.MetricsRollingStatisticalWindowBuckets == configSet2.MetricsRollingStatisticalWindowBuckets && configSet1.MetricsRollingStatisticalWindowInMilliseconds == configSet2.MetricsRollingStatisticalWindowInMilliseconds); }
public static List <HystrixThreadPoolInfo> GetHystrixThreadPoolList() { List <HystrixThreadPoolInfo> list = new List <HystrixThreadPoolInfo>(); foreach (string str in CThreadPoolFactory.AllPools.Keys.ToArray <string>()) { CThreadPool pool; CommandComponents components; if (CThreadPoolFactory.AllPools.TryGetValue(str, out pool) && HystrixCommandBase.CommandComponentsCollection.TryGetValue(str, out components)) { ICommandConfigSet configSet = components.ConfigSet; HystrixThreadPoolInfo item = new HystrixThreadPoolInfo { type = "HystrixThreadPool", name = str, currentActiveCount = pool.NowRunningWorkCount, currentCorePoolSize = pool.PoolThreadCount, currentQueueSize = pool.NowWaitingWorkCount, currentLargestPoolSize = pool.LargestPoolSize, currentMaximumPoolSize = pool.MaxConcurrentCount, currentCompletedTaskCount = pool.FinishedWorkCount, currentPoolSize = pool.CurrentPoolSize, currentTaskCount = pool.CurrentTaskCount, currentTime = CommonUtils.CurrentUnixTimeInMilliseconds, propertyValue_metricsRollingStatisticalWindowInMilliseconds = configSet.MetricsRollingStatisticalWindowInMilliseconds, propertyValue_queueSizeRejectionThreshold = (configSet.CommandMaxConcurrentCount * configSet.MaxAsyncCommandExceedPercentage) / 100, reportingHosts = 1, rollingCountThreadsExecuted = 0, rollingMaxActiveThreads = 0 }; list.Add(item); } } return(list); }
public TestCircuitBreaker() { ConfigSet = new CommandConfigSet() { CircuitBreakerEnabled = true, CircuitBreakerRequestCountThreshold = 2, CircuitBreakerErrorThresholdPercentage = 50, CircuitBreakerForceClosed = false, CircuitBreakerForceOpen = false, CircuitBreakerSleepWindowInMilliseconds = 5000, MetricsRollingStatisticalWindowBuckets = 10, MetricsRollingStatisticalWindowInMilliseconds = 10000, MetricsRollingPercentileEnabled = true, MetricsRollingPercentileWindowInMilliseconds = 60000, MetricsRollingPercentileWindowBuckets = 6, MetricsRollingPercentileBucketSize = 100, MetricsHealthSnapshotIntervalInMilliseconds = 1, CommandMaxConcurrentCount = 10, CommandTimeoutInMilliseconds = 5000, FallbackMaxConcurrentCount = 10 }; _Metrics = ComponentFactory.CreateCommandMetrics(ConfigSet, "BreakerTest", IsolationModeEnum.SemaphoreIsolation); OpenFlag = new AtomicBoolean(); CircuitOpenedOrLastTestedTime = new AtomicLong(); }
public static ICommandConfigSet CreateCustomConfigSet(IsolationModeEnum isolationMode = IsolationModeEnum.SemaphoreIsolation) { ICommandConfigSet configSet = ComponentFactory.CreateCommandConfigSet(isolationMode); configSet.ToConcrete().CircuitBreakerEnabled = false; configSet.CircuitBreakerErrorThresholdPercentage = 99; configSet.CircuitBreakerForceClosed = true; configSet.CircuitBreakerForceOpen = true; configSet.CircuitBreakerRequestCountThreshold = 99; configSet.ToConcrete().CircuitBreakerSleepWindowInMilliseconds = 4999; configSet.CommandMaxConcurrentCount = 99; configSet.CommandTimeoutInMilliseconds = 4999; configSet.DegradeLogLevel = true; configSet.FallbackMaxConcurrentCount = 4999; configSet.LogExecutionError = true; configSet.MaxAsyncCommandExceedPercentage = 99; configSet.ToConcrete().MetricsHealthSnapshotIntervalInMilliseconds = 10; configSet.ToConcrete().MetricsRollingPercentileBucketSize = 50; configSet.ToConcrete().MetricsRollingPercentileEnabled = false; configSet.ToConcrete().MetricsRollingPercentileWindowBuckets = 20; configSet.ToConcrete().MetricsRollingPercentileWindowInMilliseconds = 80 * 1000; configSet.ToConcrete().MetricsRollingStatisticalWindowBuckets = 20; configSet.ToConcrete().MetricsRollingStatisticalWindowInMilliseconds = 200 * 1000; return(configSet); }
public TestCircuitBreaker(ICommandConfigSet configSet, ICommandMetrics metrics) { ConfigSet = configSet; _Metrics = metrics; OpenFlag = new AtomicBoolean(); CircuitOpenedOrLastTestedTime = new AtomicLong(); }
public static ICommandMetrics CreateCommandMetrics(ICommandConfigSet configSet, string key, IsolationModeEnum isolationMode) { if (isolationMode == IsolationModeEnum.SemaphoreIsolation) { return(new SemaphoreIsolationCommandMetrics(configSet, key)); } return(new ThreadIsolationCommandMetrics(configSet, key)); }
public static void RaiseConfigChangeEvent(this ICommandConfigSet configSet) { IConfigChangeEvent event2 = configSet as IConfigChangeEvent; if (event2 != null) { event2.RaiseConfigChangeEvent(); } }
public static void SubcribeConfigChangeEvent(this ICommandConfigSet configSet, HandleConfigChangeDelegate handleConfigChange) { IConfigChangeEvent event2 = configSet as IConfigChangeEvent; if (event2 != null) { event2.OnConfigChanged += handleConfigChange; } }
protected override void Config(ICommandConfigSet configSet) { if (InitConfigSet == null) { base.Config(configSet); return; } ScenarioTestHelper.SetCommandConfigFrom(configSet, InitConfigSet); }
public NullLog(ICommandConfigSet configSet, Type type) { try { ConfigSet = configSet; } catch { } }
public static void SubcribeConfigChangeEvent(this ICommandConfigSet configSet, HandleConfigChangeDelegate handleConfigChange) { IConfigChangeEvent hasConfigChangeEvent = configSet as IConfigChangeEvent; if (hasConfigChangeEvent == null) { return; } hasConfigChangeEvent.OnConfigChanged += handleConfigChange; }
public CLog(ICommandConfigSet configSet, Type type) { try { this.ConfigSet = configSet; this.Logger = LogManager.GetLogger(type); } catch { } }
public static void RaiseConfigChangeEvent(this ICommandConfigSet configSet) { IConfigChangeEvent hasConfigChangeEvent = configSet as IConfigChangeEvent; if (hasConfigChangeEvent == null) { return; } hasConfigChangeEvent.RaiseConfigChangeEvent(); }
private static void OnConfigChanged(string key, ICommandConfigSet configSet) { if (!string.IsNullOrWhiteSpace(key) && (configSet != null)) { IsolationSemaphore semaphore; IsolationSemaphore semaphore2; if (((configSet.CommandMaxConcurrentCount > 0) && ExecutionSemaphores.TryGetValue(key, out semaphore)) && ((semaphore != null) && (semaphore.Count != configSet.CommandMaxConcurrentCount))) { semaphore.Count = configSet.CommandMaxConcurrentCount; } if (((configSet.FallbackMaxConcurrentCount > 0) && FallbackExecutionSemaphores.TryGetValue(key, out semaphore2)) && ((semaphore2 != null) && (semaphore2.Count != configSet.FallbackMaxConcurrentCount))) { semaphore2.Count = configSet.FallbackMaxConcurrentCount; } } }
public static void SetCommandConfigFrom(ICommandConfigSet configSet1, ICommandConfigSet configSet2) { configSet1.ToConcrete().CircuitBreakerEnabled = configSet2.ToConcrete().CircuitBreakerEnabled; configSet1.CircuitBreakerErrorThresholdPercentage = configSet2.CircuitBreakerErrorThresholdPercentage; configSet1.CircuitBreakerForceClosed = configSet2.CircuitBreakerForceClosed; configSet1.CircuitBreakerForceOpen = configSet2.CircuitBreakerForceOpen; configSet1.CircuitBreakerRequestCountThreshold = configSet2.CircuitBreakerRequestCountThreshold; configSet1.ToConcrete().CircuitBreakerSleepWindowInMilliseconds = configSet2.CircuitBreakerSleepWindowInMilliseconds; configSet1.CommandMaxConcurrentCount = configSet2.CommandMaxConcurrentCount; configSet1.CommandTimeoutInMilliseconds = configSet2.CommandTimeoutInMilliseconds; configSet1.DegradeLogLevel = configSet2.DegradeLogLevel; configSet1.FallbackMaxConcurrentCount = configSet2.FallbackMaxConcurrentCount; configSet1.LogExecutionError = configSet2.LogExecutionError; configSet1.MaxAsyncCommandExceedPercentage = configSet2.MaxAsyncCommandExceedPercentage; configSet1.ToConcrete().MetricsHealthSnapshotIntervalInMilliseconds = configSet2.MetricsHealthSnapshotIntervalInMilliseconds; configSet1.ToConcrete().MetricsRollingPercentileBucketSize = configSet2.MetricsRollingPercentileBucketSize; configSet1.ToConcrete().MetricsRollingPercentileEnabled = configSet2.MetricsRollingPercentileEnabled; configSet1.ToConcrete().MetricsRollingPercentileWindowBuckets = configSet2.MetricsRollingPercentileWindowBuckets; configSet1.ToConcrete().MetricsRollingPercentileWindowInMilliseconds = configSet2.MetricsRollingPercentileWindowInMilliseconds; configSet1.ToConcrete().MetricsRollingStatisticalWindowBuckets = configSet2.MetricsRollingStatisticalWindowBuckets; configSet1.ToConcrete().MetricsRollingStatisticalWindowInMilliseconds = configSet2.MetricsRollingStatisticalWindowInMilliseconds; }
private static void OnConfigChanged(string key, ICommandConfigSet configSet) { if (string.IsNullOrWhiteSpace(key) || configSet == null) { return; } IsolationSemaphore executionSemaphore; if (configSet.CommandMaxConcurrentCount > 0 && ExecutionSemaphores.TryGetValue(key, out executionSemaphore) && executionSemaphore != null && executionSemaphore.Count != configSet.CommandMaxConcurrentCount) { executionSemaphore.Count = configSet.CommandMaxConcurrentCount; } IsolationSemaphore fallbackExecutionSemaphore; if (configSet.FallbackMaxConcurrentCount > 0 && FallbackExecutionSemaphores.TryGetValue(key, out fallbackExecutionSemaphore) && fallbackExecutionSemaphore != null && fallbackExecutionSemaphore.Count != configSet.FallbackMaxConcurrentCount) { fallbackExecutionSemaphore.Count = configSet.FallbackMaxConcurrentCount; } }
public static ICircuitBreaker CreateCircuitBreaker(ICommandConfigSet configSet, ICommandMetrics metrics) { return(new CHystrix.CircuitBreaker.CircuitBreaker(configSet, metrics)); }
public static ILog CreateLog(ICommandConfigSet configSet, Type type) { return(new CLog(configSet, type)); }
public static void InitTestHealthSnapshotInterval(this ICommandConfigSet configSet) { configSet.ToConcrete().MetricsHealthSnapshotIntervalInMilliseconds = HealthSnapshotIntervalInMilliseconds; }
public CommandMetrics(ICommandConfigSet configSet) { ConfigSet = configSet; Reset(); }
public CommandMetrics(ICommandConfigSet configSet) { this.ConfigSet = configSet; this.Reset(); }
public static CommandConfigSet ToConcrete(this ICommandConfigSet configSet) { return((CommandConfigSet)configSet); }
public SemaphoreIsolationCommandMetrics(ICommandConfigSet configSet, string key) : base(configSet) { this.Key = key; }
private ICommandMetrics GetMetrics(ICommandConfigSet configset) { return(ComponentFactory.CreateCommandMetrics(configset, "BreakerTest", IsolationModeEnum.SemaphoreIsolation)); }
public static void Reset() { InitConfigSet = null; }
public ThreadIsolationCommandMetrics(ICommandConfigSet configSet, string key) : base(configSet) { Key = key; }
internal static CommandComponents CreateCommandComponents(string key, string instanceKey, string commandKey, string groupKey, string domain, IsolationModeEnum isolationMode, Action <ICommandConfigSet> config, Type type) { if (!key.IsValidHystrixName()) { string message = "Hystrix command key has invalid char: " + key + @". Name pattern is: ^[a-zA-Z0-9][a-zA-Z0-9\-_.]*[a-zA-Z0-9]$"; CommonUtils.Log.Log(LogLevelEnum.Fatal, message, new Dictionary <string, string>().AddLogTagData("FXD303004")); throw new ArgumentException(message); } if (!string.IsNullOrWhiteSpace(instanceKey) && !instanceKey.IsValidHystrixName()) { string str2 = "Hystrix command instanceKey has invalid char: " + instanceKey + @". Name pattern is: ^[a-zA-Z0-9][a-zA-Z0-9\-_.]*[a-zA-Z0-9]$"; CommonUtils.Log.Log(LogLevelEnum.Fatal, str2, new Dictionary <string, string>().AddLogTagData("FXD303004")); throw new ArgumentException(str2); } if (!commandKey.IsValidHystrixName()) { string str3 = "Hystrix command commandKey has invalid char: " + commandKey + @". Name pattern is: ^[a-zA-Z0-9][a-zA-Z0-9\-_.]*[a-zA-Z0-9]$"; CommonUtils.Log.Log(LogLevelEnum.Fatal, str3, new Dictionary <string, string>().AddLogTagData("FXD303004")); throw new ArgumentException(str3); } if (!groupKey.IsValidHystrixName()) { string str4 = "Hystrix command group commandKey has invalid char: " + groupKey + @". Name pattern is: ^[a-zA-Z0-9][a-zA-Z0-9\-_.]*[a-zA-Z0-9]$"; CommonUtils.Log.Log(LogLevelEnum.Fatal, str4, new Dictionary <string, string>().AddLogTagData("FXD303005")); throw new ArgumentException(str4); } if (!domain.IsValidHystrixName()) { string str5 = "Hystrix domain has invalid char: " + domain + @". Name pattern is: ^[a-zA-Z0-9][a-zA-Z0-9\-_.]*[a-zA-Z0-9]$"; CommonUtils.Log.Log(LogLevelEnum.Fatal, str5, new Dictionary <string, string>().AddLogTagData("FXD303006")); throw new ArgumentException(str5); } if (CommandCount >= MaxCommandCount) { string str6 = "Hystrix command count has reached the limit: " + MaxCommandCount; CommonUtils.Log.Log(LogLevelEnum.Fatal, str6, new Dictionary <string, string>().AddLogTagData("FXD303007")); throw new ArgumentException(str6); } CommandCount.IncrementAndGet(); ICommandConfigSet configSet = ComponentFactory.CreateCommandConfigSet(isolationMode); configSet.SubcribeConfigChangeEvent(delegate(ICommandConfigSet c) { OnConfigChanged(key, c); }); try { if (config != null) { config(configSet); } } catch (Exception exception) { CommonUtils.Log.Log(LogLevelEnum.Fatal, "Failed to config command: " + key, exception, new Dictionary <string, string>().AddLogTagData("FXD303008")); } ICommandMetrics metrics = ComponentFactory.CreateCommandMetrics(configSet, key, isolationMode); CommandComponents components = new CommandComponents { ConfigSet = configSet, Metrics = metrics, CircuitBreaker = ComponentFactory.CreateCircuitBreaker(configSet, metrics) }; CommandInfo info = new CommandInfo { Domain = domain.ToLower(), GroupKey = groupKey.ToLower(), CommandKey = commandKey.ToLower(), InstanceKey = (instanceKey == null) ? null : instanceKey.ToLower(), Key = key.ToLower(), Type = isolationMode.ToString() }; components.CommandInfo = info; components.Log = ComponentFactory.CreateLog(configSet, type); components.IsolationMode = isolationMode; return(components); }
private static void SyncConfig(object sender, ElapsedEventArgs arg) { try { if (string.IsNullOrWhiteSpace(HystrixCommandBase.ConfigServiceUrl)) { CommonUtils.Log.Log(LogLevelEnum.Warning, "Config Service Url is empty.", new Dictionary <string, string>().AddLogTagData("FXD303011")); return; } string configServiceOperationUrl = HystrixCommandBase.ConfigServiceUrl.WithTrailingSlash() + ConfigServiceOperationName + ".json"; GetApplicationConfigRequestType request = new GetApplicationConfigRequestType() { AppName = HystrixCommandBase.HystrixAppName.ToLower() }; string responseJson = configServiceOperationUrl.PostJsonToUrl(request.ToJson()); if (string.IsNullOrWhiteSpace(responseJson)) { CommonUtils.Log.Log(LogLevelEnum.Warning, "Got null response from config service: " + HystrixCommandBase.ConfigServiceUrl, new Dictionary <string, string>().AddLogTagData("FXD303012")); return; } GetApplicationConfigResponseType response = responseJson.FromJson <GetApplicationConfigResponseType>(); if (response == null) { return; } if (response.DefaultConfig != null) { if (response.DefaultConfig.CircuitBreakerErrorThresholdPercentage.HasValue && response.DefaultConfig.CircuitBreakerErrorThresholdPercentage.Value >= ComponentFactory.MinGlobalDefaultCircuitBreakerErrorThresholdPercentage && response.DefaultConfig.CircuitBreakerErrorThresholdPercentage.Value <= 100) { ComponentFactory.GlobalDefaultCircuitBreakerErrorThresholdPercentage = response.DefaultConfig.CircuitBreakerErrorThresholdPercentage; } if (response.DefaultConfig.CircuitBreakerForceClosed.HasValue) { ComponentFactory.GlobalDefaultCircuitBreakerForceClosed = response.DefaultConfig.CircuitBreakerForceClosed; } if (response.DefaultConfig.CircuitBreakerRequestCountThreshold.HasValue && response.DefaultConfig.CircuitBreakerRequestCountThreshold.Value >= ComponentFactory.MinGlobalDefaultCircuitBreakerRequestCountThreshold) { ComponentFactory.GlobalDefaultCircuitBreakerRequestCountThreshold = response.DefaultConfig.CircuitBreakerRequestCountThreshold; } if (response.DefaultConfig.CommandMaxConcurrentCount.HasValue && response.DefaultConfig.CommandMaxConcurrentCount.Value >= ComponentFactory.MinGlobalDefaultCommandMaxConcurrentCount) { ComponentFactory.GlobalDefaultCommandMaxConcurrentCount = response.DefaultConfig.CommandMaxConcurrentCount; } if (response.DefaultConfig.CommandTimeoutInMilliseconds.HasValue && response.DefaultConfig.CommandTimeoutInMilliseconds.Value >= ComponentFactory.MinGlobalDefaultCommandTimeoutInMilliseconds) { ComponentFactory.GlobalDefaultCommandTimeoutInMilliseconds = response.DefaultConfig.CommandTimeoutInMilliseconds; } if (response.DefaultConfig.FallbackMaxConcurrentCount.HasValue && response.DefaultConfig.FallbackMaxConcurrentCount.Value >= ComponentFactory.MinGlobalDefaultFallbackMaxConcurrentCount) { ComponentFactory.GlobalDefaultFallbackMaxConcurrentCount = response.DefaultConfig.FallbackMaxConcurrentCount; } } bool noValuableConfig = response.Application == null || response.Application.Commands == null || response.Application.Commands.Count == 0; Dictionary <string, CommandComponents> commandComponentsCollection = HystrixCommandBase.CommandComponentsCollection.ToDictionary(p => p.Key, p => p.Value); foreach (KeyValuePair <string, CommandComponents> pair in commandComponentsCollection) { ICommandConfigSet configSet = pair.Value.ConfigSet; if (noValuableConfig) { configSet.RaiseConfigChangeEvent(); continue; } CHystrixCommand command = response.Application.Commands.Where(c => string.Compare(c.Key, pair.Value.CommandInfo.CommandKey, true) == 0).FirstOrDefault(); if (command == null || command.Config == null) { configSet.RaiseConfigChangeEvent(); continue; } if (command.Config.CircuitBreakerErrorThresholdPercentage.HasValue && command.Config.CircuitBreakerErrorThresholdPercentage.Value > 0 && command.Config.CircuitBreakerErrorThresholdPercentage.Value <= 100) { configSet.CircuitBreakerErrorThresholdPercentage = command.Config.CircuitBreakerErrorThresholdPercentage.Value; } if (command.Config.CircuitBreakerForceClosed.HasValue) { configSet.CircuitBreakerForceClosed = command.Config.CircuitBreakerForceClosed.Value; } if (command.Config.CircuitBreakerForceOpen.HasValue) { configSet.CircuitBreakerForceOpen = command.Config.CircuitBreakerForceOpen.Value; } if (command.Config.CircuitBreakerRequestCountThreshold.HasValue && command.Config.CircuitBreakerRequestCountThreshold.Value > 0) { configSet.CircuitBreakerRequestCountThreshold = command.Config.CircuitBreakerRequestCountThreshold.Value; } if (command.Config.CommandMaxConcurrentCount.HasValue && command.Config.CommandMaxConcurrentCount.Value > 0) { configSet.CommandMaxConcurrentCount = command.Config.CommandMaxConcurrentCount.Value; } if (command.Config.CommandTimeoutInMilliseconds.HasValue && command.Config.CommandTimeoutInMilliseconds.Value > 0) { configSet.CommandTimeoutInMilliseconds = command.Config.CommandTimeoutInMilliseconds.Value; } if (command.Config.DegradeLogLevel.HasValue) { configSet.DegradeLogLevel = command.Config.DegradeLogLevel.Value; } if (command.Config.LogExecutionError.HasValue) { configSet.LogExecutionError = command.Config.LogExecutionError.Value; } if (command.Config.FallbackMaxConcurrentCount.HasValue && command.Config.FallbackMaxConcurrentCount.Value > 0) { configSet.FallbackMaxConcurrentCount = command.Config.FallbackMaxConcurrentCount.Value; } if (command.Config.MaxAsyncCommandExceedPercentage.HasValue && command.Config.MaxAsyncCommandExceedPercentage.Value >= 0 && command.Config.MaxAsyncCommandExceedPercentage.Value <= 100) { configSet.MaxAsyncCommandExceedPercentage = command.Config.MaxAsyncCommandExceedPercentage.Value; } configSet.RaiseConfigChangeEvent(); } } catch (Exception ex) { CommonUtils.Log.Log(LogLevelEnum.Warning, "Failed to sync config from config service: " + HystrixCommandBase.ConfigServiceUrl, ex, new Dictionary <string, string>().AddLogTagData("FXD303014")); } }