internal static AsyncPolicyWrap <object> GetAsyncFallBackPolicy( INHibernateLogger logger, AsyncCircuitBreakerPolicy circuitBreaker) { return(Policy <object> .Handle <BrokenCircuitException>() .Or <Alachisoft.NCache.Runtime.Exceptions.CacheException>(ex => ex.ErrorCode == NCacheErrorCodes.NO_SERVER_AVAILABLE) .FallbackAsync( fallbackAction: (ctx, ct) => { return Task.FromResult((object)null); }, onFallbackAsync: (res, ctx) => { if (logger.IsDebugEnabled()) { logger.Debug( $"AsyncFallback policy:\n" + $"\tRegion: {ctx["region"]}" + $"\tOperation: {ctx["operation"]}\n" + $"\tFallback result: {res.Result ?? "null"}"); } return Task.CompletedTask; } ) .WrapAsync(circuitBreaker)); }
internal static PolicyWrap <object> GetFallBackPolicy( INHibernateLogger logger, CircuitBreakerPolicy circuitBreaker) { return(Policy <object> .Handle <BrokenCircuitException>() .Or <Alachisoft.NCache.Runtime.Exceptions.CacheException>(ex => ex.ErrorCode == NCacheErrorCodes.NO_SERVER_AVAILABLE) .Fallback <object>( fallbackValue: null, onFallback: (res, ctx) => { if (logger.IsDebugEnabled()) { logger.Debug( $"Fallback policy:\n" + $"\tRegion: {ctx["region"]}" + $"\tOperation: {ctx["operation"]}\n" + $"\tFallback result: {res.Result ?? "null"}"); } }) .Wrap(circuitBreaker)); }
public TwoLayerCache(TwoLayerCacheConfiguration configuration) { _log = configuration.Log; _memoryCache = configuration.MemoryCache; _clientId = configuration.ClientId; _serializer = configuration.Serializer; _database = configuration.Database; _expirationEnabled = configuration.ExpirationEnabled; _useSlidingExpiration = configuration.UseSlidingExpiration; _expiration = configuration.Expiration; _appendAdditionalKeys = configuration.AppendAdditionalKeys; _appendAdditionalValues = configuration.AppendAdditionalValues; _redisGet = configuration.RedisGet; _redisGetAsync = configuration.RedisGetAsync; _redisGetMany = configuration.RedisGetMany; _redisGetManyAsync = configuration.RedisGetManyAsync; _putScript = configuration.PutScript; _removeScript = configuration.RemoveScript; _logErrorMessage = configuration.LogErrorMessage; _regionKey = configuration.RegionKey; _usePipelining = configuration.UsePipelining; _maxSynchronizationTime = configuration.MaxSynchronizationTime; var connectionMultiplexer = configuration.ConnectionMultiplexer; var invalidationChannel = string.Concat("{", configuration.RegionKey, "}@", "Invalidation"); _invalidationChannel = invalidationChannel; connectionMultiplexer.GetSubscriber().Subscribe(invalidationChannel).OnMessage((Action <ChannelMessage>)OnInvalidationMessage); connectionMultiplexer.ConnectionFailed += OnConnectionFailed; connectionMultiplexer.ErrorMessage += OnErrorMessage; connectionMultiplexer.ConnectionRestored += OnConnectionRestored; }
static MemCacheProvider() { log = NHibernateLogger.For(typeof(MemCacheProvider)); config = ConfigurationManager.GetSection("enyim.com/memcached") as IMemcachedClientConfiguration; if (config == null) { log.Info("enyim.com/memcached configuration section not found, using default configuration (127.0.0.1:11211)."); config = new MemcachedClientConfiguration(); config.Servers.Add(new IPEndPoint(IPAddress.Loopback, 11211)); } }
internal static AsyncCircuitBreakerPolicy GetAsyncCircuitBreakerPolicy( RegionConfig regionConfig, CacheConfig cacheConfig, INHibernateLogger logger) { return(Policy .Handle <Alachisoft.NCache.Runtime.Exceptions.CacheException>(ex => ex.ErrorCode == NCacheErrorCodes.NO_SERVER_AVAILABLE) .CircuitBreakerAsync( exceptionsAllowedBeforeBreaking: regionConfig.CircuitBreakerExceptionsAllowed, durationOfBreak: TimeSpan.FromSeconds( regionConfig.CircuitBreakerDurationOfBreak), onBreak: (ex, ts, ctx) => { if (logger.IsDebugEnabled()) { logger.Debug( $"AsyncCircuitbreaker policy:\n" + $"\tRegion: {ctx["region"]}" + $"\tOperation: {ctx["operation"]}" + $"\tCircuit broken for " + $"{cacheConfig.CacheId}\n" + $"\tReason:{ex.Message}"); } }, onReset: (ctx) => { if (logger.IsDebugEnabled()) { logger.Debug( $"AsyncCircuitbreaker policy:\n" + $"\tRegion: {ctx["region"]}" + $"\tCircuit reset for {cacheConfig.CacheId}"); } }, onHalfOpen: () => { if (logger.IsDebugEnabled()) { logger.Debug( $"AsyncCircuitbreaker policy:\n" + $"\tCircuit half-open for" + $" {cacheConfig.CacheId}"); } } )); }
/// <summary> /// The constructor for creating the region strategy. /// </summary> /// <param name="connectionMultiplexer">The Redis connection.</param> /// <param name="configuration">The region configuration.</param> /// <param name="properties">The NHibernate configuration properties.</param> protected AbstractRegionStrategy(IConnectionMultiplexer connectionMultiplexer, RedisCacheRegionConfiguration configuration, IDictionary <string, string> properties) { Log = NHibernateLogger.For(GetType()); RegionName = configuration.RegionName; Expiration = configuration.Expiration; UseSlidingExpiration = configuration.UseSlidingExpiration; AppendHashcode = configuration.AppendHashcode; RegionKey = configuration.RegionKey; ConnectionMultiplexer = connectionMultiplexer; Database = configuration.DatabaseProvider.Get(connectionMultiplexer, configuration.Database); Serializer = configuration.Serializer; LockTimeout = configuration.LockConfiguration.KeyTimeout; _keyLocker = new RedisKeyLocker(RegionName, Database, configuration.LockConfiguration); }
public static void LogMapped(this Property property, INHibernateLogger log) { if (log.IsDebugEnabled()) { var msg = "Mapped property: " + property.Name; var columns = string.Join(",", property.Value.ColumnIterator.Select(c => c.Text).ToArray()); if (columns.Length > 0) { msg += " -> " + columns; } var propertyTypeName = SafeGetPropertyTypeName(property); if (propertyTypeName != null) { msg += ", type: " + propertyTypeName; } log.Debug(msg); } }
public static TType GetInstance <TType>(string key, IDictionary <string, string> properties, TType defaultValue, INHibernateLogger logger) { var objectsFactory = Cfg.Environment.ObjectsFactory; var className = GetString(key, properties, null); System.Type type = null; try { if (className != null) { type = ReflectHelper.ClassForName(className); return((TType)objectsFactory.CreateInstance(type)); } // Try to get the instance from the base type if the user provided a custom IObjectsFactory if (!(objectsFactory is ActivatorObjectsFactory)) { try { return((TType)objectsFactory.CreateInstance(typeof(TType))); } catch (Exception e) { // The user most likely did not register the TType logger.Debug( "Failed to create an instance of type '{0}' by using IObjectsFactory, most probably was not registered. Exception: {1}", typeof(TType), e); } } return(defaultValue); } catch (Exception e) { throw new HibernateException( $"Could not instantiate {typeof(TType).Name}: {type?.AssemblyQualifiedName ?? className}", e); } }
static MemCacheProvider() { log = NHibernateLogger.For(typeof(MemCacheProvider)); var configs = ConfigurationManager.GetSection("memcache") as MemCacheConfig[]; if (configs != null) { var myWeights = new ArrayList(); var myServers = new ArrayList(); foreach (MemCacheConfig config in configs) { myServers.Add(string.Format("{0}:{1}", config.Host, config.Port)); log.Debug("adding config for memcached on host {0}", config.Host); if (config.Weight > 0) { myWeights.Add(config.Weight); } } servers = (string[])myServers.ToArray(typeof(string)); weights = (int[])myWeights.ToArray(typeof(int)); } }
public void NewLoggerFactoryTimingsForNoLogging(int iteration) { ResetCounts(); NHibernateLogger.SetLoggersFactory((INHibernateLoggerFactory)null); INHibernateLogger logger2 = NHibernateLogger.For(this.GetType()); var stopwatch = Stopwatch.StartNew(); var iterationCount = 10000000; for (int i = 0; i < iterationCount; i++) { logger2.Debug("message"); logger2.Debug("message with parameters {0}, {1}", "string", 5); } stopwatch.Stop(); Console.WriteLine( "{0} wrote {1:N0} characters to log in {2} ms", nameof(NewLoggerFactoryTimingsForDisabledLogging), GetCounts(), stopwatch.ElapsedMilliseconds); }
static CoreDistributedCacheProvider() { Log = NHibernateLogger.For(typeof(CoreDistributedCacheProvider)); ConfiguredCachesProperties = new Dictionary <string, IDictionary <string, string> >(); if (!(ConfigurationManager.GetSection("coredistributedcache") is CacheConfig config)) { return; } if (!string.IsNullOrEmpty(config.FactoryClass)) { try { var factoryClass = ReflectHelper.ClassForName(config.FactoryClass); var ctorWithProperties = factoryClass.GetConstructor(CacheFactoryCtorWithPropertiesSignature); CacheFactory = (IDistributedCacheFactory)(ctorWithProperties != null ? ctorWithProperties.Invoke(new object[] { config.Properties }): Cfg.Environment.ObjectsFactory.CreateInstance(factoryClass)); } catch (Exception e) { throw new HibernateException( $"Could not create the {nameof(IDistributedCacheFactory)} factory from '{config.FactoryClass}'. " + $"(It must implement {nameof(IDistributedCacheFactory)} and have a constructor accepting a " + $"{nameof(IDictionary<string, string>)} or have a parameterless constructor.)", e); } } foreach (var cache in config.Regions) { ConfiguredCachesProperties.Add(cache.Region, cache.Properties); } AppendHashcodeToKey = config.AppendHashcodeToKey; }
public void OldLoggerFactoryThunkedTimingsForEnabledLogging(int iteration) { ResetCounts(); ILoggerFactory loggerFactory = new MockLoggerFactory(); LoggerProvider.SetLoggersFactory(loggerFactory); INHibernateLogger logger2 = NHibernateLogger.For(this.GetType()); var stopwatch = Stopwatch.StartNew(); var iterationCount = 10000000; for (int i = 0; i < iterationCount; i++) { logger2.Warn("message"); logger2.Warn("message with parameters {0}, {1}", "string", 5); } stopwatch.Stop(); Console.WriteLine( "{0} wrote {1:N0} characters to log in {2} ms", nameof(OldLoggerFactoryThunkedTimingsForEnabledLogging), GetCounts(), stopwatch.ElapsedMilliseconds); }
public static void Info(this INHibernateLogger logger, string format, params object[] args) { logger.Log(NHibernateLogLevel.Info, new NHibernateLogValues(format, args), null); }
public static void Warn(this INHibernateLogger logger, Exception exception, string message) { logger.Log(NHibernateLogLevel.Warn, new NHibernateLogValues(message, null), exception); }
public static void Debug(this INHibernateLogger logger, string message, Exception ex) => ThrowNotImplemented();
public static bool IsFatalEnabled(this INHibernateLogger logger) => logger.IsEnabled(NHibernateLogLevel.Fatal);
public static bool IsErrorEnabled(this INHibernateLogger logger) => logger.IsEnabled(NHibernateLogLevel.Error);
public static bool IsWarnEnabled(this INHibernateLogger logger) => logger.IsEnabled(NHibernateLogLevel.Warn);