public static bool Execute(string line, KLog uploaderLog) { var cleanLine = line.Replace("#KLOG_INSTANCE_STATUS#", ""); cleanLine = cleanLine.Replace("KLOG_VERSION_", ""); InstanceModel instanceHeader; try { instanceHeader = JsonConvert.DeserializeObject <InstanceModel>(cleanLine); var checkAddInstanceStart = DataAccessor.AddInstanceStart(instanceHeader); if (!checkAddInstanceStart.Success) { uploaderLog.Error($"SQL Expection on [UploadFirstLine].[AddInstanceStart] - Message: {checkAddInstanceStart.Message}"); return(false); } } catch (Exception ex) { uploaderLog.Error($"Expection on [UploadFirstLine].[DeserializeInstanceHeader] - Message: {ex.ToString()}"); return(false); } return(true); }
public static bool Execute(string line, KLog uploaderLog) { var cleanLine = line.Replace("#KLOG_INSTANCE_STATUS#", ""); InstanceModel instanceHeader = null; try { instanceHeader = JsonConvert.DeserializeObject <InstanceModel>(cleanLine); } catch (Exception ex) { uploaderLog.Error($"Expection on [UploadLastLine].[DeserializeInstanceFooter] - Message: {ex.ToString()}"); return(false); } var checkUpdateInstanceStop = DataAccessor.UpdateInstanceStop(instanceHeader); if (!checkUpdateInstanceStop.Success) { uploaderLog.Error($"SQL Expection on [UploadLastLine].[UpdateInstanceStop] - Message: {checkUpdateInstanceStop.Message}"); return(false); } return(true); }
/// <summary> /// Query Kiroku Storage for a single KLOG. /// </summary> /// <param name="req"></param> /// <returns></returns> public static OkObjectResult Execute(HttpRequest req) { using (KLog klog = new KLog($"KQueryManager,Execute")) { if (!_configOnline) { klog.Error("Config failed to load."); return(new OkObjectResult("")); } if (req == null) { klog.Warning("Request was empty."); return(new OkObjectResult("")); } string id = req?.Query["id"]; try { Guid checkId = new Guid(id); byte[] doc = Storage.GetLog(id); var payload = Encoding.UTF8.GetString(doc, 0, doc.Length); if (!string.IsNullOrEmpty(payload)) { payload = payload.Replace("#KLOG_INSTANCE_STATUS#", ""); payload = payload.Replace("}", "},"); payload = "[" + payload + "]"; payload = payload.Replace("},\r\n$", "}]"); payload = JValue.Parse(payload).ToString(Formatting.Indented); } if (doc == null) { klog.Error($"Document is null. Id: {id}"); } return(doc == null ? new OkObjectResult($"404") : new OkObjectResult(payload)); } catch (Exception ex) { klog.Error($"EXCEPTION : {ex.ToString()}"); return(new OkObjectResult("")); } } }
public static void Execute() { // Blob retention using (KLog blobRetention = new KLog("BlobFileRetention-BlobRetention")) { try { IEnumerable <BlobFileModel> retentionFileCollection = BlobFileCollection.CurrentRetentionCount(); blobRetention.Info($"Retention Count: {retentionFileCollection.Count()}"); foreach (BlobFileModel blobFile in retentionFileCollection) { // for each file, confim check one more blobRetention.Info($"Retention => File Name: {blobFile.CloudFile}"); string cloudFile = blobFile.CloudFile; try { BlobClient.DeleteBlobFile(cloudFile); blobRetention.Info($"File Deleted => File Name: {blobFile.CloudFile}"); } catch (Exception ex) { blobRetention.Error($"Delete Failure: {blobFile.CloudFile} Exception: {ex}"); } } } catch (Exception ex) { blobRetention.Error($"BlobFileRetention Exception: {ex.ToString()}"); } } // SQL Retention using (KLog sqlRetention = new KLog("BlobFileRetention-SQLRetention")) { try { SQLResponseModel checkRetention = DataAccessor.Retention(Configuration.RetentionDays); if (!checkRetention.Success) { sqlRetention.Error($"SQL Expection on [BlobFileRetention].[Retention] - Message: {checkRetention.Message}"); } } catch (Exception ex) { sqlRetention.Error($"BlobFileRetention Exception: {ex.ToString()}"); } } }
/// <summary> /// Method for getting the correct position for the user's entry. /// First available one if the user has no entry already. /// </summary> /// <param name="id">The ID of the user</param> /// <returns>The row number for the entry</returns> public static int GetEntryPos(ulong id) { int i = 2; ExcelRange cells = StrikeLog.Workbook.Worksheets[StrikeLogPage].Cells; while (cells["A" + i].Value != null) { ulong spot; if (!ulong.TryParse(cells[$"A{i}"].Value.ToString().Replace("'", ""), out spot)) { KLog.Error($"INVALID ID IN STRIKE LOG {cells[$"A{i}"].Value.ToString().Replace("'", "")}"); throw new Exception("Invalid Number."); } if (spot == id) { return(i); } i++; } return(i); }
public static void Execute() { using (KLog collectorLog = new KLog("ClassBlobFileCollector-MethodExecute")) { try { var token = new BlobContinuationToken(); var blobCollection = BlobClient.BlobContainer.ListBlobsSegmentedAsync(null, token).GetAwaiter().GetResult(); List <string> blobPrefixNames = blobCollection.Results.OfType <CloudBlobDirectory>().Select(b => b.Prefix).ToList(); collectorLog.Info($"Collector => Prefix Count: {blobPrefixNames.Count()}"); // flush static object BlobFileCollection.StaticFlush(); // for each dir in the blob container foreach (var blobPrefixName in blobPrefixNames) { var prefixblobCollection = BlobClient.BlobContainer.ListBlobsSegmentedAsync(blobPrefixName, token).GetAwaiter().GetResult(); List <string> prefixblobFileNames = prefixblobCollection.Results.OfType <CloudBlockBlob>().Select(b => b.Name).ToList(); collectorLog.Info($"Collector => Parsing Prefix: {blobPrefixName}"); BlobFileParser.Execute(blobPrefixName, prefixblobFileNames); } } catch (Exception ex) { collectorLog.Error($"BlobFileCollector Exception: {ex.ToString()}"); } } }
/// <summary> /// Delete local "KLOG_A_$(guid).txt" files that exceed the provided retention period (in days). /// </summary> /// <param name="retentionFiles"></param> public static void Retention(IEnumerable <FileModel> retentionFiles) { using (KLog logRetention = new KLog("ClassProcessor-MethodRetention")) { try { foreach (var retentionFile in retentionFiles) { // TODO: clean-up check + checkBool var check = ((DateTime.UtcNow.AddDays(Configuration.RetentionDays)) < retentionFile.FileDate) ? "Hold" : "Delete"; var checkBool = ((DateTime.UtcNow.AddDays(Configuration.RetentionDays)) < retentionFile.FileDate); logRetention.Info($"Retention File Operation => Time: {retentionFile.FileDate.ToString()}, Result: {check.ToString()}, File: {retentionFile.FileName}"); if (!checkBool) { File.Delete(retentionFile.FullPath); logRetention.Info($"Retention File Operation => |- Delete File: {retentionFile.FileName}"); } } } catch (Exception ex) { logRetention.Error($"{ex.ToString()}"); } } }
public static bool Execute(string line, Guid fileGuid, KLog uploaderLog) { uploaderLog.Warning($"Uploader => Footer Check Failed - Guid: {fileGuid.ToString()}"); BlobFileCollection.GetFiles().First(d => d.FileGuid == fileGuid).FooterStatus = false; LogRecordModel record = null; try { record = JsonConvert.DeserializeObject <LogRecordModel>(line); } catch (Exception ex) { uploaderLog.Error($" [UploadInstanceStop] Log Record Deserialize Exception: {ex.ToString()}"); return(false); } var newEndTime = record.EventTime; InstanceModel newInstanceCloser = new InstanceModel(); newInstanceCloser.InstanceID = fileGuid; newInstanceCloser.EventTime = newEndTime; var checkUpdateInstaceClose = DataAccessor.UpdateInstanceStop(newInstanceCloser); if (!checkUpdateInstaceClose.Success) { uploaderLog.Error($"SQL Expection on [UploadInstanceStop].[UpdateInstaceClose] - Message: {checkUpdateInstaceClose.Message}"); return(false); } var checkUpdateBlockStop = DataAccessor.UpdateBlockEmptyStop(record, fileGuid); if (!checkUpdateBlockStop.Success) { uploaderLog.Error($"SQL Expection on [UploadInstanceStop].[UpdateBlockStop] - Message: {checkUpdateBlockStop.Message}"); return(false); } return(true); }
public static void Execute() { using (KLog checkLog = new KLog("ClassBlobFileCheck-MethodExecute")) { try { foreach (var file in BlobFileCollection.GetFiles()) { if (file.FileGuid != Guid.Empty) { var resultResponse = DataAccessor.CheckInstanceId(file.FileGuid); if (!resultResponse.Success) { checkLog.Error($"SQL Expection on [BlobFileCheck].[CheckInstance] - Message: {resultResponse.Message}"); break; } if (resultResponse.Id != Guid.Empty) { BlobFileCollection.GetFiles().First(d => d.FileGuid == file.FileGuid).Exist = true; checkLog.Info($"Instance Check => Guid: {file.FileGuid.ToString()} Result: true"); } else { BlobFileCollection.GetFiles().First(d => d.FileGuid == file.FileGuid).Exist = false; checkLog.Info($"Instance Check => Guid: {file.FileGuid.ToString()} Result: false"); } } else { BlobFileCollection.GetFiles().First(d => d.FileGuid == file.FileGuid).Exist = true; checkLog.Info($"Instance Check => Guid: {file.FileGuid.ToString()} Result: true (empty guid)"); } } } catch (Exception ex) { checkLog.Error($"BlobfileCheck Expection: {ex.ToString()}"); } } }
/// <summary> /// Delete local "KLOG_A_$(guid).txt" files that exceed the configured retention period (in days). /// </summary> /// <param name="retentionFiles"></param> public static void Execute() { using (KLog logRetention = new KLog("ClassDeleteLogs-MethodExecute")) { try { if (Capsule.DeleteFileCount() > 0) { foreach (var retentionFile in Capsule.DeleteFiles) { // TODO: clean-up check + checkBool if (Configuration.RetentionDays < 0) { var check = ((DateTime.UtcNow.AddDays(Configuration.RetentionDays)) < retentionFile.FileDate) ? "Hold" : "Delete"; var checkBool = ((DateTime.UtcNow.AddDays(Configuration.RetentionDays)) < retentionFile.FileDate); logRetention.Info($"Retention File Operation => Time: {retentionFile.FileDate.ToString()}, Result: {check.ToString()}, File: {retentionFile.FileName}"); if (!checkBool) { File.Delete(retentionFile.FullPath); logRetention.Info($"Retention File Operation => |- Delete File: {retentionFile.FileName}"); } } else { File.Delete(retentionFile.FullPath); logRetention.Info($"Retention File Operation => |- Delete File: {retentionFile.FileName}"); } } } else { logRetention.Info("No files were marked for retention."); } } catch (Exception ex) { logRetention.Error($"{ex.ToString()}"); } } }
public static bool Execute(string line, List <LogRecordModel> recordModelList, KLog uploaderLog) { try { var record = JsonConvert.DeserializeObject <LogRecordModel>(line); if (CheckWriteByType(record.LogType)) { recordModelList.Add(record); } } catch { uploaderLog.Error($"Uploader [AddLogToCollection] => Line Exception: {line}"); return(false); } return(true); }
// this should pass in a single List<BlobFileModel> public static void Execute(string blobPrefixName, List <string> prefixblobFileNames) { using (KLog parserLog = new KLog("ClassBlobFileParser-MethodExecute")) { try { foreach (var file in prefixblobFileNames) { var fileNameWithoutPrefix = file.Replace(blobPrefixName, ""); BlobFileModel blobFile = new BlobFileModel(); blobFile.File = fileNameWithoutPrefix; blobFile.CloudFile = file; // Check and parse the full log file name if (fileNameWithoutPrefix.Count() == 47 && fileNameWithoutPrefix.Contains("KLOG_")) { var parseGuid = Guid.Parse(fileNameWithoutPrefix.Substring(7, 36)); var parseTag = fileNameWithoutPrefix.Substring(1, 6); blobFile.FileGuid = parseGuid; blobFile.Tag = parseTag; blobFile.ParseStatus = true; parserLog.Info($"Parser => File Name: {fileNameWithoutPrefix} Tag: {parseTag} Guid: {parseGuid}"); } else { blobFile.ParseStatus = false; } BlobFileCollection.AddFile(blobFile); } } catch (Exception ex) { parserLog.Error($"BlobFileParser Exception: {ex.ToString()}"); } } }
/// <summary> /// Identify local "KLOG_W_$(guid).txt" files (orpahned) that exceed the configured retention period (in hours). The files are renamed (re-queued) to "KLOG_S_$(guid).txt" for sending. /// </summary> /// <param name="cleanupFiles"></param> public static void Execute() { using (KLog logCleanse = new KLog("ClassCleanseLogs-MethodExecute")) { try { if (Capsule.CleanUpFileCount() > 0) { foreach (var cleanseFile in Capsule.CleanUpFiles) { // TODO: clean-up check + checkBool var check = ((DateTime.UtcNow.AddHours(Configuration.CleanseHours)) < cleanseFile.FileDate) ? "Hold" : "Rename"; var checkBool = ((DateTime.UtcNow.AddHours(Configuration.CleanseHours)) < cleanseFile.FileDate); logCleanse.Info($"Cleanse File Operation => Time: {cleanseFile.FileDate.ToString()}, Result: {check.ToString()}, File: {cleanseFile.FileName}"); if (!checkBool) { var renamefileName = cleanseFile.Path + @"\KLOG_S_" + cleanseFile.FileGuid.ToString() + ".txt"; File.Move(cleanseFile.FullPath, renamefileName); logCleanse.Info($"Cleanse File Operation => |- Rename File: {renamefileName}"); } } } else { logCleanse.Info("No files required clean-up."); } } catch (Exception ex) { logCleanse.Error($"{ex.ToString()}"); } } }
public static async Task AddTitle(SocketGuildUser user, int titleid) { if (!NodeMap.ContainsKey(titleid)) { KLog.Error($"Attempted to give user {BotUtils.GetFullUsername(user)} invalid title ID #{titleid}"); return; } TitleNode node = NodeMap[titleid]; if (node == null) { KLog.Error($"Attempted to give user {BotUtils.GetFullUsername(user)} null title with ID #{titleid}"); return; } UserDataNode u = UserDataManager.GetUserData(user); if (u.Titles == null) { u.Titles = new List <int>(); } if (u.Titles.Contains(titleid)) { return; // Don't give duplicate titles } u.Titles.Add(titleid); node.OnComplete(user); KLog.Important($"User {BotUtils.GetFullUsername(user)} has earned title {node.Name}"); UserDataManager.SaveUserData(); await AnnounceAchievement(user, node); }
public static void Execute() { using (KLog uploaderLog = new KLog("ClassBlobFileUploader-MethodExecute")) { // Load files not currently uploaded var existFileCollction = BlobFileCollection.CurrentExistFalseCount(); try { foreach (var blobFile in existFileCollction) { try { // Set variables var cloudFile = blobFile.CloudFile; var fileGuid = blobFile.FileGuid; var lineCounter = 1; List <LogRecordModel> recordModelList = new List <LogRecordModel>(); List <string> lines = new List <string>(); var document = BlobClient.GetDocument(cloudFile); lines = ReadFile.Execute(document); var lineCountTotal = lines.Count(); uploaderLog.Info($"Uploader => Starting Upload - Guid: {fileGuid.ToString()} Line Count: {lineCountTotal} "); // // Read each line in the log file. Check first and last line for KLog instance data. Break loop on any unexcpted data or failure. // foreach (var line in lines) { // // Check first line -- expecting the KLog instane "header" // if (lineCounter == 1) { if (line.Contains("#KLOG_INSTANCE_STATUS#")) { var checkUploadFirstLine = UploadFirstLine.Execute(line, uploaderLog); if (!checkUploadFirstLine) { uploaderLog.Error($"[BlobFileUploader].[checkUploadFirstLine] - GUID: {fileGuid}"); break; } } else { UploadFirstLine.MarkFailure(fileGuid); uploaderLog.Error($"Uploader => Header Check Failed - Guid: {fileGuid.ToString()} Line: {line}"); break; } lineCounter++; } // // Check last line -- expecting the KLog instance "footer" and add all logs. // else if (lineCounter == lineCountTotal) { // Post all logs var checkUploadAllLogs = UploadAllLogs.Execute(recordModelList, fileGuid, uploaderLog); if (!checkUploadAllLogs) { uploaderLog.Error($"[BlobFileUploader].[UploadAllLogs] - GUID: {fileGuid}"); break; } // Check for a proper KLog instance "footer" if (line.Contains("#KLOG_INSTANCE_STATUS#")) { var checkUploadLastLine = UploadLastLine.Execute(line, uploaderLog); if (!checkUploadLastLine) { uploaderLog.Error($"[BlobFileUploader].[UploadLastLine] - GUID: {fileGuid}"); } } else { var checkUploadInstanceStop = UploadInstanceStop.Execute(line, fileGuid, uploaderLog); if (!checkUploadInstanceStop) { uploaderLog.Error($"[BlobFileUploader].[UploadInstanceStop] - GUID: {fileGuid}"); } } uploaderLog.Info($"Log Loaded - Guid: {fileGuid.ToString()}"); } // // Check line for "normal" log record, add to collection to bulk add later. // else { var checkAddLogToCollection = AddLogToCollection.Execute(line, recordModelList, uploaderLog); if (!checkAddLogToCollection) { uploaderLog.Error($"[BlobFileUploader].[AddLogToCollection] - GUID: {fileGuid}"); break; } lineCounter++; } } } catch (Exception ex) { uploaderLog.Error($"Blob Upload Failure - Exception: {ex}"); } } } catch (Exception ex) { uploaderLog.Error($"BlobFileUploader Exception: {ex}"); } } }
public static bool Execute(List <LogRecordModel> recordModelList, Guid fileGuid, KLog uploaderLog) { Dictionary <Guid, LogRecordModel> blockCache = new Dictionary <Guid, LogRecordModel>(); foreach (var record in recordModelList) { if (record.LogData.Contains("KLOG_BLOCK")) { if (record.LogData.Contains("KLOG_BLOCK_START")) { blockCache.Add(record.BlockID, record); } else if (record.LogData.Contains("KLOG_BLOCK_STOP")) { var startBlock = blockCache[record.BlockID]; if (startBlock != null) { var checkAddBlockResponse = DataAccessor.AddBlock(record, startBlock, instanceId: fileGuid); if (!checkAddBlockResponse.Success) { uploaderLog.Error($"SQL Expection on [UploadAllLogs].[AddBlock] - Message: {checkAddBlockResponse.Message}"); return(false); } } else { uploaderLog.Error($"Starting Block not found, is missing from Block pair."); } blockCache.Remove(record.BlockID); } else { uploaderLog.Error($"Malformed Block"); } } else { if (record.LogType == "Metric") { var jsonString = record.LogData.Replace("#", "\""); var metric = JsonConvert.DeserializeObject <MetricRecordModel>(jsonString); var checkMetricResponse = DataAccessor.AddMetric(record, metric, instanceId: fileGuid); if (!checkMetricResponse.Success) { uploaderLog.Error($"SQL Expection on [UploadAllLogs].[AddMetric] - Message: {checkMetricResponse.Message}"); return(false); } } else if (record.LogType == "Result") { var jsonString = record.LogData.Replace("#", "\""); var result = JsonConvert.DeserializeObject <ResultRecordModel>(jsonString); var checkResultResponse = DataAccessor.AddResult(record, result, instanceId: fileGuid); if (!checkResultResponse.Success) { uploaderLog.Error($"SQL Expection on [UploadAllLogs].[AddResult] - Message: {checkResultResponse.Message}"); return(false); } } else { if (record.LogData.Length > Configuration.MessageLength) { var messageCap = Configuration.MessageLength - 20; var cleanLogData = "[ERROR-MAX-" + Configuration.MessageLength + "]"; cleanLogData += record.LogData.Substring(1, messageCap); record.LogData = cleanLogData; } var checkAddInstanceStop = DataAccessor.AddLog(record, instanceId: fileGuid); if (!checkAddInstanceStop.Success) { uploaderLog.Error($"SQL Expection on [UploadAllLogs].[AddLog] - Message: {checkAddInstanceStop.Message}"); return(false); } } } } return(true); }
/// <summary> /// Send "KLOG_S_$(guid).txt" files to Azure Storage Blob. On success, local file is renamed to "KLOG_A_$(guid).txt" to set as archive. /// </summary> /// <param name="sendFiles"></param> /// <param name="containerName"></param> public static void Execute() { using (KLog logSend = new KLog("ClassSendLogs-MethodExecute")) { try { if (Capsule.SendFileCount() > 0) { logSend.Info($" File Count => {Capsule.SendFileCount().ToString()}"); foreach (var sendFile in Capsule.SendFiles) { // Parse connection string CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Configuration.AzureStorage); // Create the blob client CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); // Retrieve container reference -- create if it's not availble CloudBlobContainer container = blobClient.GetContainerReference(Configuration.AzureContainer); container.CreateIfNotExistsAsync().Wait(); // Build KLOG _R_ead file name to use on the blob write var blobfileName = @"\KLOG_R_" + sendFile.FileGuid.ToString() + ".txt"; // Retrieve blob reference -- example: containerName\$(localDir)\KLOG_R_$(guid).txt CloudBlockBlob blockBlob = container.GetBlockBlobReference(sendFile.DirName + blobfileName); // Check if the file already exist before trying to send if (!blockBlob.ExistsAsync().GetAwaiter().GetResult()) { // Create or overwrite the "myblob" blob with contents from a local file using (var fileStream = System.IO.File.OpenRead(sendFile.FullPath)) { blockBlob.UploadFromStreamAsync(fileStream).GetAwaiter().GetResult(); logSend.Info($"Send Status => Sending: {blockBlob.Name}"); } // Check and then Rename local file after file has been sent to Azure Storage Blob if ((container.GetBlockBlobReference(sendFile.DirName + blobfileName)).ExistsAsync().GetAwaiter().GetResult()) { logSend.Info("Send Status => |- Transmission Confirmed."); var renamefileName = sendFile.Path + @"\KLOG_A_" + sendFile.FileGuid.ToString() + ".txt"; logSend.Info($"Send Status => |- Renaming: {renamefileName}"); File.Move(sendFile.FullPath, renamefileName); } } // Files already exist in Azure Storage Blob -- rename local file for archiving else { logSend.Info($"Send Status => Exist. Skip Sending File: {sendFile.FileName}"); var renamefileName = sendFile.Path + @"\KLOG_A_" + sendFile.FileGuid.ToString() + ".txt"; logSend.Info($"Send Status => |- Renaming: {renamefileName}"); File.Move(sendFile.FullPath, renamefileName); } } } else { logSend.Info("No files were sent."); } } catch (Exception ex) { logSend.Error($"{ex.ToString()}"); } } }
/// <summary> /// Collect and tag all local "KLOG_$(tag)_$(guid).txt" files from provided filepath. /// </summary> /// <param name="filePath"></param> /// <returns>List of FileModel type</returns> public static List <FileModel> Execute(string filePath) { List <FileModel> fileMetadata = new List <FileModel>(); using (KLog log = new KLog("ClassCollectLogs-MethodExecute")) { try { // Search for all folders in the provide root filePath -- if you're using KLOG for more than one service locally, divide them by folders here var directories = Directory.GetDirectories(filePath); foreach (var d in directories) { // Logging DirectoryInfo dInfo = new DirectoryInfo(d); log.Info($"DirectoryInfo => Full Directory: {d}"); log.Info($"DirectoryInfo => Directory Name: {dInfo.Name}"); // Scan each folder for KLOG's foreach (var file in dInfo.GetFiles("*.txt")) { FileModel fileModel = new FileModel(); // if KLOG if (file.Name.Count() == 47 && file.Name.Contains("KLOG_")) { // Load metadata fileModel.FullPath = file.FullName; fileModel.Path = file.DirectoryName; fileModel.FileName = file.Name; fileModel.TagCode = -1; fileModel.FileDate = file.LastWriteTimeUtc; fileModel.DirName = dInfo.Name; // Parse file name down to GUID and Tag fileModel.FileGuid = Guid.Parse(file.Name.Substring(7, 36)); fileModel.Tag = file.Name.Substring(1, 6); if (file.Name.Contains("KLOG_S")) { fileModel.TagCode = 1; } if (file.Name.Contains("KLOG_W")) { fileModel.TagCode = 2; } if (file.Name.Contains("KLOG_A")) { fileModel.TagCode = 3; } // Logging log.Info($"GetFileDetails => FullPath: {fileModel.FullPath}"); log.Info($"GetFileDetails => |- Tag: {fileModel.Tag}, Tag Code: {fileModel.TagCode}, File Date: {fileModel.FileDate}"); fileMetadata.Add(fileModel); } } } } catch (Exception ex) { log.Error($"{ex.ToString()}"); } } return(fileMetadata); }
static void Main(string[] args) { Console.WriteLine("Testing Static Kiroku Logger"); KManager.Configure(Global.KirokuTagList); KManager.Open(); using (KLog klog = new KLog("testing block one")) { klog.Trace("testing trace one"); klog.Info("testing info one"); klog.Warning("testing warning one"); klog.Error("testing error one"); klog.Metric("test one", 1); klog.Success("test one success"); } KManager.Close(); KManager.Configure(Global.KirokuTagList, dynamic: true); Console.WriteLine("\n\rTrying to use Static Logger while Dynamic=true Kiroku Logger"); try { KManager.Open(); } catch (Exception ex) { Console.WriteLine($"Open Exception: {ex.ToString()}"); } try { KManager.Close(); } catch (Exception ex) { Console.WriteLine($"Close Exception: {ex.ToString()}"); } Console.WriteLine("\n\rTesting Non-Nested Dynamic Kiroku Logger"); using (KLog klog = new KLog("testing block two")) { klog.Trace("testing trace two"); klog.Info("testing info two"); klog.Warning("testing warning two"); klog.Error("testing error two"); klog.Metric("test two", 1); klog.Success("test two success"); } Console.WriteLine("\n\rTesting Nested Dynamic Kiroku Logger"); using (KLog klog = new KLog("testing block three")) { klog.Trace("testing trace three"); klog.Info("testing info three"); klog.Warning("testing warning three"); klog.Error("testing error three"); klog.Metric("test three", 1); klog.Success("test three success"); using (KLog klog2 = new KLog("nested testing block three", klog)) { klog2.Trace("nested testing trace three"); klog2.Info("nested testing info three"); klog2.Warning("nested testing warning three"); klog2.Error("nested testing error three"); klog2.Metric("nested test three", 1); klog2.Success("nested test three success"); } } Console.WriteLine("\n\rTesting Task<Nested Dynamic> Kiroku Logger"); //#region Dynamic-False //for (int instanceIteration = 1; instanceIteration <= Global.InstanceLoop; instanceIteration++) //{ // KManager.Online(Global.KirokuTagList); // for (int blockIteration = 1; blockIteration <= Global.BlockLoop; blockIteration++) // { // using (KLog klog = new KLog($"Block-{instanceIteration}-{blockIteration}")) // { // klog.Metric("Test Metric One", blockIteration); // klog.Metric("Test Metric Two", true); // klog.Metric("Test Metric Three", 2.33); // if (Global.TraceOn) // { // try // { // // Trace // for (int traceMeter = 1; traceMeter <= Global.TraceLoopCount; traceMeter++) // { // klog.Trace(Generator.Execute(Global.TraceCharCount)); // } // // Info // if (Global.InfoOn) // { // for (int infoMeter = 1; infoMeter <= Global.InfoLoopCount; infoMeter++) // { // klog.Info(Generator.Execute(Global.InfoCharCount)); // } // } // // Warning // if (Global.WarningOn) // { // for (int warningMeter = 1; warningMeter <= Global.WarningLoopCount; warningMeter++) // { // klog.Warning(Generator.Execute(Global.WarningCharCount)); // } // } // // Error // if (Global.ErrorOn) // { // for (int errorMeter = 1; errorMeter <= Global.ErrorLoopCount; errorMeter++) // { // klog.Error(Generator.Execute(Global.ErrorCharCount)); // } // } // klog.Success(); // } // catch (Exception e) // { // klog.Error($"KFlow Exception: {e.ToString()}"); // klog.Failure(); // } // } // } // } // KManager.Offline(); //} //#endregion var items = new string[] { "Task1", "Task2", "Task3", "Task4" }; var tasks = new Task[items.Length]; var taskCounter = 0; foreach (var item in items) { tasks[taskCounter] = new Task(() => DynamicLog(item)); taskCounter++; } Parallel.ForEach(tasks, (t) => { t.Start(); }); Task.WaitAll(tasks); Console.ReadKey(); }