Esempio n. 1
0
        public async Task WriteMessage(LogLevel FLogLevel, string stackInfo, string message, string args, LoggerBllType bllType, Exception exception)
        {
            var entity = new TLogger
            {
                FBllType   = bllType,
                FLogLevel  = FLogLevel,
                FStackInfo = stackInfo,
                FMessage   = message,
                FArgs      = args,
            };

            if (exception != null)
            {
                entity.FExceptionName    = exception.GetType().Name;
                entity.FExceptionMessage = exception.Message;
                entity.FExceptionInfo    = exception.ToString();
            }

            entity.SetCreator("Sys");
            ConsoleLogger.WriteMessage(entity);

#if SERVER
            await LoggerWriter.FileWriterFatory.WriteMessage(entity);

            await LoggerWriter.MongoWriterFatory.WriteMessage(entity);
#endif
            await Task.CompletedTask;
        }
        public void WriteMessage(TLogger entity)
        {
#if SERVER
            ConsoleWriters[entity.FLogLevel].ShowMessage(entity);
#else
            ConsoleWriters[LogLevel.Debug].ShowMessage(entity);
#endif
        }
        public async Task WriteMessage(TLogger entity)
        {
            if (!CanWrite(entity.FLogLevel))
            {
                return;
            }

            await Game.Scene.GetComponent <LoggerRpository>().WriteLogger(entity);
        }
Esempio n. 4
0
        public void ShowMessage(TLogger entity)
        {
#if SERVER
            if (entity.FLogLevel != this.LogLevel)
            {
                return;
            }
#endif

            if (!CanShow(this.LogLevel))
            {
                return;
            }

            MessageBuilder.Clear();
            var    last       = entity.FStackInfo.LastIndexOf('\\');
            string lastString = null;
            if (!string.IsNullOrEmpty(entity.FStackInfo) && last < entity.FStackInfo.Length)
            {
                lastString = entity.FStackInfo.Substring(entity.FStackInfo.LastIndexOf('\\') + 1);
            }
            MessageBuilder.Append($"{DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss ")}{Enum.GetName(typeof(LogLevel), this.LogLevel)} {lastString}");
            if (!string.IsNullOrEmpty(entity.FMessage))
            {
                MessageBuilder.Append($" {entity.FMessage}");
            }
            if (!string.IsNullOrEmpty(entity.FArgs))
            {
                MessageBuilder.Append($" args:{entity.FArgs}");
            }
            if (!string.IsNullOrEmpty(entity.FExceptionName))
            {
                MessageBuilder.AppendLine();
                MessageBuilder.AppendLine($"name:{entity.FExceptionName}");
                MessageBuilder.AppendLine($"message:{entity.FExceptionMessage}");
                MessageBuilder.AppendLine($"exception:{entity.FExceptionInfo.Trim()}");
            }
            ConsoleLogger.ShowMessage(MessageBuilder.ToString());
        }
Esempio n. 5
0
        private string GenrateLogString(TLogger entity)
        {
            var builder = new StringBuilder();

            builder.Append($"{DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss ")}{Enum.GetName(typeof(LogLevel), this.LogLevel)} {entity.FStackInfo}");
            if (!string.IsNullOrEmpty(entity.FMessage))
            {
                builder.Append($" {entity.FMessage}");
            }
            if (!string.IsNullOrEmpty(entity.FArgs))
            {
                builder.Append($" args:{entity.FArgs}");
            }
            if (!string.IsNullOrEmpty(entity.FExceptionName))
            {
                builder.AppendLine();
                builder.AppendLine($"name:{entity.FExceptionName}");
                builder.AppendLine($"message:{entity.FExceptionMessage}");
                builder.AppendLine($"exception:{entity.FExceptionInfo.Trim()}");
            }
            return(builder.ToString());
        }
Esempio n. 6
0
        public async Task WriteMessage(TLogger entity)
        {
            if (!CanWrite(this.LogLevel))
            {
                return;
            }

            var levelName  = FileInfoManager.LevelNames[this.LogLevel];
            var customName = GetCustomNameName();
            var fileName   = GenerateFileName(customName, levelName);

            var isCreateNew = FileInfoManager.LogFiles.Add(fileName);

            if (isCreateNew)
            {
                CreateFile(customName, levelName, fileName);
            }
            else
            {
                OpenFile(fileName);
            }

            var logStr = GenrateLogString(entity);

            try
            {
                await this.logOutput.WriteLineAsync(logStr);

                this.logOutput.Flush();
                FileInfoManager.LastCreateFileSize[this.LogLevel] += logStr.Length;
                await this.SyncContext;
            }
            catch (Exception e)
            {
                Console.Write(e.ToString());
            }
        }
        public async Task WriteMessage(TLogger entity)
        {
            var writer = FileWriters[entity.FLogLevel];

            await writer.WriteMessage(entity);
        }