/// <summary> /// Add AbpFx Resource /// </summary> /// <param name="services"></param> /// <param name="virtualPath"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> public static II18NServiceCollection AddAbpResourceFrom(this II18NServiceCollection services, string virtualPath) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (string.IsNullOrWhiteSpace(virtualPath)) { throw new ArgumentNullException(nameof(virtualPath)); } var path = PathHelper.Combine(services.ExposeOptions, virtualPath, true); try { foreach (var filePath in PathHelper.GetSeveralPathList(path)) { using (var bridgeAdapter = new AbpJsonFileAdapter(filePath)) { if (bridgeAdapter.Process()) { var speaker = bridgeAdapter.Speak(); services.ExposeOptions.AddResource(speaker.PackageKey, TranslateResourceFactory.Create(speaker)); } } } } catch (Exception exception) { InternalLogger.WriteLine($"Thrown exception when add json resource from {path}, message: {0}", exception.Message); } return(services); }
private static void LogNonFormattableEvent(LogEvent logEvent, Exception e) { InternalLogger.WriteLine( "Event at {0} with message template {1} could not be formatted into JSON and will be dropped: {2}", logEvent.Timestamp.ToString("o"), logEvent.MessageTemplate.Text, e); }
private void ParseAndInsertLogEventIntoQueueAutomatically(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate, ILogCallerInfo callerInfo, LogEventContext context = null, params object[] messageTemplateParameters) { var task = CreateEnqueueTask(); task.ContinueWith(t => DispatchForAutomatic()); task.Start(); Task CreateEnqueueTask() { var taskResult = new Task(async() => { var writer = await _automaticAsyncQueue.AcquireWriteAsync(1, CancellationToken.None); writer.Visit( succeeded => { _messageParameterProcessor.Process(messageTemplate, __as(messageTemplateParameters, context), out var parsedTemplate, out var namedMessageProperties, out var positionalMessageProperties); var logEvent = new LogEvent(StateNamespace, eventId, level, parsedTemplate, exception, LogEventSendMode.Automatic, callerInfo, _upstreamRenderingOptions, namedMessageProperties, positionalMessageProperties, context, messageProcessorShortcut: _messageParameterProcessor); if (succeeded.ItemCount >= 1) { _automaticAsyncQueue.ReleaseWrite(logEvent); } else { _automaticAsyncQueue.ReleaseWrite(); } return(logEvent); }, cancelled => { InternalLogger.WriteLine("When insert log event(0) into async queue, task has been cancelled."); return(null); }, faulted => { InternalLogger.WriteLine( $@"Thrown an exception when insert log event(0) into async queue:{Environment.NewLine}{faulted.Exception.ToUnwrappedString()}", faulted.Exception); return(null); }); }); return(taskResult); object[] __as(object[] __paramObjs, LogEventContext __context) { if (__paramObjs == null || !__paramObjs.Any()) { return(__context?.Parameters.ToArray()); } return(__paramObjs.GetType() != typeof(object[]) ? new object[] { __paramObjs } : __paramObjs); } } }
private static void ProcessError(HttpResponseMessage response, string uri) { if (!response.IsSuccessStatusCode) { InternalLogger.WriteLine(@"Tencent Cloud CLS call failed: Status Code : {0} Request Uri : {1}", response.StatusCode, uri); } }
private static void ProcessError(PutResponse response) { if (response.Error != null) { InternalLogger.WriteLine(@"JD Cloud Log Service call failed: Request Id : {0} Error Code : {1} Error Message: {2}", response.RequestId, response.Error.Code, response.Error.Message); } }
private static void ProcessError(IResponse response) { if (!response.IsSuccess) { InternalLogger.WriteLine(@"Aliyun SLS call failed: Request Id : {0} Error Code : {1} Error Message: {2}", response.RequestId, response.Error.ErrorCode, response.Error.ErrorMessage); } }
void FlushToDisk(IFlushableAstronaut flushable) { try { if (Interlocked.CompareExchange(ref _flushRequired, 0, 1) == 1) { flushable.FlushToDisk(); } } catch (Exception exception) { InternalLogger.WriteLine("{0} could not flush the underlying sink to disk: {1}", typeof(PeriodicAstronaut), exception); } }
/// <summary> /// Add from stream /// </summary> /// <param name="stream"></param> public void AddFromStream(Stream stream) { try { var bf = new BinaryFormatter(); if (bf.Deserialize(stream) is List <MessageTemplate> buffer) { AddInternal(buffer); } } catch { InternalLogger.WriteLine("Throw exception when deserialize stream to List<MessageTemplate>."); } }
/// <summary> /// Create a new instance of <see cref="PeriodicAstronaut"/>. /// </summary> /// <param name="astronaut"></param> /// <param name="flushInterval"></param> public PeriodicAstronaut(IAstronaut astronaut, TimeSpan flushInterval) { _astronaut = astronaut ?? throw new ArgumentNullException(nameof(astronaut)); if (_astronaut is IFlushableAstronaut flushable) { _timer = new Timer(_ => FlushToDisk(flushable), null, flushInterval, flushInterval); } else { _timer = new Timer(_ => { }, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan); InternalLogger.WriteLine("{0} configured to flush {1}, but {2} not implemented", typeof(PeriodicAstronaut), astronaut, nameof(IFlushableAstronaut)); } }
public static bool TryResolveCompilerGeneratedType(object value, PropertyResolvingMode mode, NestParameterResolver nest, Type typeOfValue, bool raiseException, int positionalValue, out MessagePropertyValue result) { if (mode == PropertyResolvingMode.Destructure) { result = new StructureValue(StructureElements(), Tag()); return(true); string Tag() { var __tag = typeOfValue.Name; if (string.IsNullOrWhiteSpace(__tag) || typeOfValue.IsCompilerGeneratedType()) { __tag = null; } return(__tag); } IEnumerable <MessageProperty> StructureElements() { foreach (var property in value.GetType().GetPropertiesRecursive()) { dynamic propertyValue; try { propertyValue = property.GetValue(value); } catch (TargetParameterCountException) { InternalLogger.WriteLine("The property accessor '{0}' is a non-default indexer", property); continue; } catch (TargetInvocationException ex) { InternalLogger.WriteLine("The property accessor '{0}' threw exception: {1}", property, ex); if (raiseException) { throw; } propertyValue = $"Threw an exception at: {ex.InnerException?.GetType().Name}"; } yield return(new MessageProperty(property.Name, positionalValue, nest.CreatePropertyValue(propertyValue, PropertyResolvingMode.Destructure))); } } } result = null; return(false); }
private static II18NServiceCollection AddXmlAnonymousResourceFromOnce(II18NServiceCollection services, string path, bool referenceToBasePath) { try { using (var adapter = new AnonymousXmlFileAdapter(PathHelper.Combine(services.ExposeOptions, path, referenceToBasePath))) { if (adapter.Process()) { var speaker = adapter.Speak(); services.ExposeOptions.AddAnonymousResource(TranslateResourceFactory.Create(speaker)); } } } catch (Exception exception) { InternalLogger.WriteLine($"Thrown exception when add json resource from {path}, message: {0}", exception.Message); } return(services); }
public static void Handle(HttpApplication application) { if (application == null) { return; } var logger = StaticServiceResolver.Instance.GetLogger <HttpApplication>(); var exception = application.Server.GetLastError(); var statusCode = application.Response.StatusCode; if (statusCode >= 500) { var realException = exception.Unwrap(); var paramObj = new { FxName = Constants.AspNetMvcName, UsedTime = Constants.Unknown, StatusCode = statusCode, ExceptionDetails = exception.Message, ExceptionType = exception.GetType(), ExceptionMessage = exception.Message, RealExceptionType = realException.GetType(), RealExceptionMessage = realException.Message, }; logger.LogFatal(exception, WebTemplateStandard.WebLog500, paramObj); } else if (statusCode >= 400) { var paramObj = new { FxName = Constants.AspNetMvcName, UsedTime = Constants.Unknown, StatusCode = statusCode, ExceptionDetails = exception.Message }; logger.LogError(exception, WebTemplateStandard.WebLog400, paramObj); } else { InternalLogger.WriteLine("Status code should not less than 400 when occurred error."); } }
private void DispatchForAutomatic(int desiredItems = 1) { var readerTask = new Task(async() => { bool more = true; while (more) { var result = await _automaticAsyncQueue.AcquireReadAsync(desiredItems, CancellationToken.None); result.Visit( succeeded => { LogEvent logEvent = null; if (succeeded is AcquireReadSucceeded <LogEvent> acquireReader) { logEvent = acquireReader.Items[0]; Dispatch(logEvent); } if (succeeded.ItemCount < 1) { more = false; } _automaticAsyncQueue.ReleaseRead(succeeded.ItemCount); return(logEvent); }, cancelled => { InternalLogger.WriteLine("Dispatching task has been cancelled."); return(null); }, faulted => { InternalLogger.WriteLine( $@"Thrown an exception when dispatch log event from async queue:{Environment.NewLine}{faulted.Exception.ToUnwrappedString()}", faulted.Exception); return(null); }); } }); readerTask.Start(); }
private static void UpdateTinyIoCContainer(TinyIoCContainer container) { var provider = NancyContainerSolo.ServiceProvider; container.Register <IServiceProvider>(provider, NancyContainerSolo.Name); var registrations = AllComponentsRegistrations; foreach (var registration in registrations) { var serviceType = registration.Many ? typeof(IEnumerable <>).MakeGenericType(registration.ServiceType) : registration.ServiceType; if (registration.Lifetime == ServiceLifetime.Singleton) { if (registration.Many) { container.Register(serviceType, provider.GetServices(registration.ServiceType)).AsSingleton(); } else { container.Register(serviceType, provider.GetService(registration.ServiceType)).AsSingleton(); } } else if (registration.Lifetime == ServiceLifetime.Scoped) { InternalLogger.WriteLine("PreRequestSingleton do not supported by TinyIoC in NancyFX, but the Official's one does."); } else if (registration.Lifetime == ServiceLifetime.Transient) { if (registration.Many) { container.Register(serviceType, provider.GetServices(registration.ServiceType)).AsMultiInstance(); } else { container.Register(serviceType, provider.GetService(registration.ServiceType)).AsMultiInstance(); } } } }
public static void OnEndHandle(HttpApplication application) { if (application == null) { return; } var ms = application.Context.Items[TimeKey] is DateTime stamp?DateTime.Now.Subtract(stamp).TotalMilliseconds : 0L; application.Context.Items.Remove(TimeKey); var logger = StaticServiceResolver.Instance.GetLogger <HttpApplication>(); var exception = application.Server.GetLastError(); if (exception != null) { var statusCode = application.Response.StatusCode; if (statusCode >= 500) { var realException = exception.Unwrap(); var paramObj = new { FxName = Constants.AspNetMvcName, UsedTime = $"{ms} ms", StatusCode = statusCode, ExceptionDetails = exception.Message, ExceptionType = exception.GetType(), ExceptionMessage = exception.Message, RealExceptionType = realException.GetType(), RealExceptionMessage = realException.Message, }; logger.LogFatal(exception, WebTemplateStandard.WebLog500, paramObj); } else if (statusCode >= 400) { var paramObj = new { FxName = Constants.AspNetMvcName, UsedTime = $"{ms} ms", StatusCode = statusCode, ExceptionDetails = exception.Message }; logger.LogError(exception, WebTemplateStandard.WebLog400, paramObj); } else { InternalLogger.WriteLine("Status code should not less than 400 when occurred error."); } } else { var paramObj = new { FxName = Constants.AspNetMvcName, UsedTime = $"{ms} ms", StatusCode = application.Response.StatusCode, ExceptionDetails = Constants.Null }; if (ms > 1000) { logger.LogWarning(WebTemplateStandard.LongNormal, paramObj); } else { logger.LogDebug(WebTemplateStandard.Normal, paramObj); } } }