private static void WriteLog(LogLevels level, string message)
{
if (!Directory.Exists(LogFolder))
{
Directory.CreateDirectory(LogFolder);
}
if (level >= Settings.settingsStore.logLevel)
{
string output;
if (Settings.settingsStore.useUTCTimeInLog)
{
output = "[" + DateTime.UtcNow.ToString("HH:mm:ss") + "][" + level.ToString() + "] : " + message;
}
else
{
output = "[" + DateTime.Now.ToString("HH:mm:ss") + "][" + level.ToString() + "] : " + message;
}
Console.WriteLine(output);
ClientHandler.SendConsoleMessageToAdmins(output);
try
{
lock (logLock) {
File.AppendAllText(LogFilename, output + Environment.NewLine);
}
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine("Error writing to log file!, Exception: " + e);
Console.ForegroundColor = ConsoleColor.Gray;
}
}
}
private void LogData(string message, LogLevels level, Exception exception)
{
if (LogLevel <= level)
{
if (exception == null)
{
LogData(string.Format("{0} - {1} - {2} - {3}", DateTime.Now.ToString("MM/dd/yyyy HH:nn:ss.fffff"), ClassLogger.ToString(), level.ToString(), message));
}
else
{
LogData(string.Format("{0} - {1} - {2} - {3}::\r\n{4}", DateTime.Now.ToString("MM/dd/yyyy HH:nn:ss.fffff"), ClassLogger.ToString(), level.ToString(), message, exception.ToString()));
}
}
}
/// <summary>
/// Logs a message to the database logger.
/// If logger not defined, logs to the console.
/// </summary>
public static void AltLog(LogLevels eventType, int id, string message, bool forceconsole = false)
{
if (!forceconsole && Logger != null)
Logger.TraceEvent(eventType, id, message);
else
Console.WriteLine(eventType.ToString() + " " + id + " " + LMLoggers.LognLM.FlattenChars(message));
}
public static string Format(DateTime dateTime,LogLevels level,string toWrite)
{
var levelString = level.ToString().Substring(3).ToUpper();
return string.Format("{0:0000}/{1:00}/{2:00} {3:00}:{4:00}:{5:00} ({6}) {7}",
dateTime.Year,
dateTime.Month,
dateTime.Day,
dateTime.Hour,
dateTime.Minute,
dateTime.Second,
levelString,
toWrite
);
}
private static void WriteLog(LogLevels level, string format, params object[] args)
{
if (level < MinLogLevel) { return; }
lock (Console.Out)
{
string Line = string.Format("[{0}] [{1}] : {2}", DateTime.Now.ToString("HH:mm:ss"), level.ToString(), string.Format(format, args));
Console.WriteLine(Line);
try
{
File.AppendAllText(LogFilename, Line + Environment.NewLine);
}
catch { } //What do we do about this?
}
}
private static void WriteLog(LogLevels level, string message)
{
if (!Directory.Exists(logDir))
{
Directory.CreateDirectory(logDir);
}
string output = "[" + DateTime.Now.ToString("HH:mm:ss") + "][" + level.ToString() + "] : " + message;
Console.WriteLine(output);
try
{
File.AppendAllText(logFile, output + Environment.NewLine);
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine("Error writing to log file!, Exception: " + e);
Console.ForegroundColor = ConsoleColor.Gray;
}
}
private static void WriteLog(LogLevels level, string format, params object[] args)
{
if (level < MinLogLevel) { return; }
string output = string.Format("[{0}] : {1}", level.ToString(), string.Format(format, args));
switch (level)
{
case LogLevels.Debug:
case LogLevels.Activity:
case LogLevels.Info:
case LogLevels.Notice:
UnityEngine.Debug.Log(output);
break;
case LogLevels.Warning:
UnityEngine.Debug.LogWarning(output);
break;
case LogLevels.Error:
UnityEngine.Debug.LogError(output);
break;
}
}
private static void WriteLog(LogLevels level, string format, params object[] args)
{
if (level < MinLogLevel)
{
return;
}
lock (Console.Out)
{
string Line = string.Format("[{0}] [{1}] : {2}", DateTime.Now.ToString("HH:mm:ss"), level.ToString(), string.Format(format, args));
Console.WriteLine(Line);
try
{
File.AppendAllText(LogFilename, Line + Environment.NewLine);
}
catch { } //What do we do about this?
}
}
private static void _print(string txt, LogLevels lvl)
{
lock (sem_consolePrint)
{
string msg = DateTime.Now.ToString(logDateFormat) + txt;
msg = string.Format("{0} [{1}]: {2}"
, new string[] { DateTime.Now.ToString(logDateFormat), lvl.ToString(), txt });
if (writeToConsole)
{
Console.WriteLine(msg);
}
if (writeToLog)
{
sb_log.Append(Environment.NewLine + msg);
}
}
}
static void Main(string[] args)
{
//acl_demo();
//return;
PrintInfo();
if (args.Length < 1 || string.IsNullOrWhiteSpace(args[0]))
{
PrintUsage();
return;
}
myFirstDir = args[0];
Console.WriteLine(" {root directory} :: '" + myFirstDir + "'");
Console.WriteLine();
LoadInputParameters();
print.trace("Logging started");
print.info("Parameters loaded from App.config:");
print.info("ThreadCount=" + th_cnt.ToString());
print.info("HowManyItemsPerThread=" + item_per_th_cnt.ToString());
print.info("LogFilePath=" + logFilePath.ToString());
print.info("WriteLogToFile=" + writeToLog.ToString());
print.info("WriteLogToConsole=" + writeToConsole.ToString());
print.info("LogDateFormat=" + logDateFormat.ToString());
print.info("LogLevel=" + LogLevel.ToString());
if (!Directory.Exists(myFirstDir))
{
print.FATAL("Directory '" + myFirstDir + "' does not exists! (EXIT)");
return;
}
if (writeToLog && (string.IsNullOrWhiteSpace(logFilePath) || !Directory.Exists(Path.GetDirectoryName(logFilePath))))
{
print.FATAL("Write to log file is enabled but directory for log file does not exists! '" + logFilePath + "' (EXIT)");
return;
}
//icacls "c:\test" /reset /T /C /Q
DateTime dtstart = DateTime.Now;
int citems = 0;
int cdirs = 0;
int cfiles = 0;
int citemschgd = 0;
Queue <string> filesToTravers = new Queue <string>();
//setup threading vars
ParameterizedThreadStart tsp_oneParamQueueString = new ParameterizedThreadStart(th_execQueue);
Thread[] my_threads = new Thread[th_cnt];
//create a queue for traversing through dirs and insert the root directory
Queue <string> dirsToTravers = new Queue <string>();
dirsToTravers.Enqueue(myFirstDir);
//create a queues for file paths one per each thread
Queue <string>[] fileQueues = new Queue <string> [th_cnt];
for (int i = 0; i < th_cnt; i++)
{
fileQueues[i] = new Queue <string>();
}
//main loop for traversing through dirs & files
int current_thread = 0;
for (; dirsToTravers.Count > 0; cdirs++)
{
string curfolder = dirsToTravers.Dequeue();
fileQueues[current_thread].Enqueue(curfolder);
//every new folder should be added to the directory queue
foreach (string myDir in Directory.EnumerateDirectories(curfolder))
{
print.debug("dir : " + myDir);
dirsToTravers.Enqueue(myDir);
}
//every new file should be handled
foreach (string myfile in Directory.EnumerateFiles(curfolder))
{
//continue;
print.debug("file: " + myfile);
cfiles++;
fileQueues[current_thread].Enqueue(myfile);
//when current file queue is full create a thread to do the job
if (fileQueues[current_thread].Count >= item_per_th_cnt)
{
my_threads[current_thread] = new Thread(new ParameterizedThreadStart(tsp_oneParamQueueString));
my_threads[current_thread].Start(fileQueues[current_thread]);
//move to the next thread
current_thread = (current_thread + 1) % th_cnt;
//wait for the thread to complete before continuing to make sure that the Queue is already empty
//[this aproach might be futherly optimize]
if (my_threads[current_thread] != null)
{
my_threads[current_thread].Join();
}
}
}
}
if (fileQueues[current_thread].Count > 0)
{
//last batch of files. Thread {current_thread} is already joined in the above loop
my_threads[current_thread] = new Thread(new ParameterizedThreadStart(tsp_oneParamQueueString));
my_threads[current_thread].Start(fileQueues[current_thread]);
}
print.debug("//need to wait for the all threads to finish");
for (int i = 0; i < th_cnt; i++)
{
print.debug("//trying to close thread " + i.ToString());
if (my_threads[i] != null)
{
my_threads[i].Join();
}
print.debug("//thread " + i.ToString() + " is closed");
}
citems = cfiles + cdirs;
//disabled single-threaded single-folder version
if (false)
{
foreach (string myfile in Directory.EnumerateFileSystemEntries(myFirstDir))
{
filesToTravers.Enqueue(myfile);
citems++;
}
for (; filesToTravers.Count > 0;)
{
string myfile = filesToTravers.Dequeue();
//j += Program.RemoveInheritance(myfile, true) ? 1 : 0;
//Program.RemoveInheritance(myfile, true);
Program.RestoreInheritanceAndDeleteAllOtherRules(myfile);
}
}
//calculate time of the run
DateTime dtend = DateTime.Now;
TimeSpan ts = dtend.Subtract(dtstart);
//print some statistics
print.info(string.Format("Work finished in : {0:n4} s", ts.TotalSeconds));
print.info("Number of items: " + citems.ToString() + ", files: " + cfiles + ", dirs: " + cdirs);
print.info(string.Format("Successfully processed {0} files; Failed processing {1} files", th_itemscnt, th_itemscnt_failed));
if (writeToLog)
{
System.IO.File.WriteAllText(logFilePath, sb_log.ToString());
}
}
public void Log(LogLevels level, string message)
{
ExecuteApplication("log", level.ToString().ToUpper() + " " + message, false);
}
public void SetSessionLogLevel(LogLevels level)
{
ExecuteApplication("session_loglevel", level.ToString().ToLower(), true);
}
private static void WriteLog(LogLevels level, string format, params object[] args)
{
if (!Directory.Exists(LogFolder))
{
Directory.CreateDirectory(LogFolder);
}
if (level < MinLogLevel)
{
return;
}
lock (Console.Out)
{
string Line = string.Format("[{0}] [{1}] : {2}", DateTime.Now.ToString("HH:mm:ss"), level.ToString(), string.Format(format, args));
Console.WriteLine(Line);
try
{
File.AppendAllText(LogFilename, Line + Environment.NewLine);
}
catch { } //What do we do about this?
Console.ForegroundColor = ConsoleColor.Gray;
}
}
private static void logToFile(string message, LogLevels level, DateTime dateTime, string exceptionMessage, string stack, int sourceId, int exceptionId)
{
try
{
var dateString = dateTime.ToString("yyyy/MM/dd hh:mm:sstt");
var indentStr = new string(' ', dateString.Length + 2); // +2 to accommodate log type and spaces
if (!string.IsNullOrEmpty(message))
{
message = message.Replace("\r\n", "\r").Replace("\n", "\r").Replace("\r", " | ");
}
if (!string.IsNullOrEmpty(exceptionMessage))
{
exceptionMessage = exceptionMessage.Replace("\r\n", "\r").Replace("\n", "\r").Replace("\r", " | ");
}
var levelSymbol = level.ToString()[0];
var logText = "";
switch (level)
{
case LogLevels.Debug:
case LogLevels.Info:
// basic non-error logging
logText = string.Format(
"{0} {1} {2} (Source {3})\r\n",
dateString,
levelSymbol,
message,
sourceId);
break;
case LogLevels.Warning:
case LogLevels.Error:
case LogLevels.FatalError:
// get that stack trace indented!
string indentedStack = "";
if (stack != null)
{
indentedStack = stack.Replace("\r\n", "\r\n" + indentStr);
indentedStack = indentStr + indentedStack.Substring(0, indentedStack.Length - indentStr.Length);
}
// log exception details
logText = string.Format(
"{0} {1} {2} (SourceID {3})\r\n{4} {5} (ExceptionID {6})\r\n{7}\r\n\r\n",
dateString,
levelSymbol,
message,
sourceId,
indentStr,
exceptionMessage,
exceptionId,
indentedStack);
break;
}
//log to the correct stream if configured, otherwise log to default location (not efficient as the file is opened each time)
if (_logFileStream != null)
{
_logFileStream.Write(logText);
if ((_logFileMaxSize > 0) && (_logFileStream.BaseStream.Length > _logFileMaxSize))
{
truncateFile();
}
}
else
{
lock (_fileLock)
{
//2012/03/15 - params were the wrong way round!
File.AppendAllText(DefaultLogFileName, logText);
}
}
}
catch
{
}
}
public static void Log(this object source, LogLevels level, string message, string logWindowID = LogWindows.DefaultLogWindowID)
{
// TODO: Add better log logic here!
LogWindows.SendToWindow(logWindowID, System.DateTime.Now.ToString() + " [ " + level.ToString() + " ] : " + message);
}
protected override void LogStatement(string message, LogLevels level)
{
var msg = $"{DateTime.Now} :: {level.ToString().PadLeft(12)}: {message}";
LogStatement(msg);
}
private static void SendToAdmin(LogLevels level, string format, params object[] args)
{
try {
string Line = string.Format("[{0}] : {1}", level.ToString (), string.Format(format, args));
ServerMain.server.sendTextMessageToAdmins(Line);
}
catch (Exception) {};
}
/// <summary>
/// Overload to write a message and exception to the logging system
/// </summary>
/// <param name="LoggerType">Type of logger to use</param>
/// <param name="LogLevel">Level of log reporting</param>
/// <param name="InpMsg">Message to be logged</param>
/// <param name="Ex">Exception to be logged</param>
public static void WriteLog(LoggerTypes LoggerType, LogLevels LogLevel, string InpMsg, Exception Ex)
{
ILog MyLogger;
//Establish which logger will be used
switch (LoggerType)
{
case LoggerTypes.LogDb:
MyLogger = m_DbLogger;
break;
case LoggerTypes.LogFile:
MyLogger = m_FileLogger;
// Check to determine if a new file should be started
var TestFileDate = DateTime.Now.ToString("MM-dd-yyyy");
if (TestFileDate != m_FileDate)
{
m_FileDate = TestFileDate;
ChangeLogFileName();
}
break;
case LoggerTypes.LogSystem:
MyLogger = m_SysLogger;
break;
default:
throw new Exception("Invalid logger type specified");
}
//Update the status file data
clsStatusData.MostRecentLogMessage = DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss") + "; "
+ InpMsg + "; " + LogLevel.ToString();
//Send the log message
switch (LogLevel)
{
case LogLevels.DEBUG:
if (MyLogger.IsDebugEnabled)
MyLogger.Debug(InpMsg, Ex);
break;
case LogLevels.ERROR:
clsStatusData.AddErrorMessage(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss") + "; " + InpMsg
+ "; " + LogLevel.ToString());
if (MyLogger.IsErrorEnabled)
MyLogger.Error(InpMsg, Ex);
break;
case LogLevels.FATAL:
if (MyLogger.IsFatalEnabled)
MyLogger.Fatal(InpMsg, Ex);
break;
case LogLevels.INFO:
if (MyLogger.IsInfoEnabled)
MyLogger.Info(InpMsg, Ex);
break;
case LogLevels.WARN:
if (MyLogger.IsWarnEnabled)
MyLogger.Warn(InpMsg, Ex);
break;
default:
throw new Exception("Invalid log level specified");
}
}
private static void WriteLog(LogLevels level, string format, params object[] args)
{
if (!Directory.Exists(LogFolder))
Directory.CreateDirectory(LogFolder);
if (level < MinLogLevel) { return; }
lock (Console.Out)
{
string Line = string.Format("[{0}] [{1}] : {2}", DateTime.Now.ToString("HH:mm:ss"), level.ToString(), string.Format(format, args));
Console.WriteLine(Line);
try
{
File.AppendAllText(LogFilename, Line + Environment.NewLine);
}
catch { } //What do we do about this?
Console.ForegroundColor = ConsoleColor.Gray;
}
}
public void Write(String input, LogLevels level)
{
// Check if we even need to handle this level.
if (level < llevel)
{
return;
}
if (file == null)
{
file = System.IO.File.AppendText(lfile);
}
// wait for our mutex to clear before we continue.
while (!lmutex)
{
Thread.Sleep(1);
}
// Claim our mutex.
lmutex = false;
var msg = String.Format("[{0}][{1}] {2}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), level.ToString(), input);
Console.WriteLine(msg);
file.WriteLine(msg);
// Release our mutex.
lmutex = true;
}
/// <summary>
/// Logs a message to the database logger.
/// Composes the .ENT format string with the args to prepare the message string.
/// If logger not defined, logs to the console.
/// </summary>
public static void AltLog(LogLevels eventType, int id, string format, params object[] args)
{
if (Logger != null)
Logger.TraceEvent(eventType, id, format, args);
else
Console.WriteLine(eventType.ToString() + " " + id + " " + LMLoggers.LognLM.FlattenChars(String.Format(format, args)));
}
/// <summary>
/// Write a message in the log file
/// </summary>
private void Write(LogLevels logLevel, string className, string memberName, string message, int numberWriteErrors = 3)
{
if (_isActivated)
{
StreamWriter sw = null;
try
{
string fileNameWithDate = $"{DateTime.Now.ToString("yyyy_MM_dd")}_{LogFileName}";
string absolutePath = $"{LogDirectory}/{fileNameWithDate}";
string currentDate = DateTime.Now.ToString("dd/MM/yyyy");
string currentTime = DateTime.Now.ToString("HH:mm:ss");
string completeMessage = $"{currentDate}\t{currentTime}\t{Thread.CurrentThread.ManagedThreadId}\t{logLevel.ToString()}\t{className}\t{memberName}\t{message}";
sw = new StreamWriter(absolutePath, true);
Console.WriteLine(completeMessage);
sw.WriteLine(completeMessage);
sw.Flush();
sw.Dispose();
sw.Close();
}
catch
{
Thread.Sleep(500);
if (numberWriteErrors > 0)
{
numberWriteErrors--;
Write(logLevel, className, memberName, message, numberWriteErrors);
}
}
}
}
private static void ConsoleLog(string message, LogLevels logLevel = LogLevels.Debug)
{
Console.WriteLine($"【{logLevel.ToString()}】 {message}");
}
private async void Log(DateTime dateTimeStamp, LogLevels level, Type logInitiator, string loggedFrom, string message)
{
//Always verify the log level before adding a log entry.
if (level >= _logLevel)
{
string methodName;
switch (level)
{
case LogLevels.All:
methodName = "Log";
break;
case LogLevels.Info:
methodName = "LogInfo";
break;
case LogLevels.Warn:
methodName = "LogWarn";
break;
case LogLevels.Error:
methodName = "LogError";
break;
case LogLevels.Fatal:
methodName = "LogFatal";
break;
default:
methodName = "LogDebug";
break;
}
StringParameters dsp = null;
if (level == LogLevels.All)
{
dsp = new StringParameters();
dsp.Add(new StringParameter(PARAM_NAME_LEVEL, level.ToString()));
}
logBase log = new logBase(dateTimeStamp, logInitiator.FullName, loggedFrom, message);
FacadeResponse<string> fr;
fr = await JsonFacade.SendRequest<string>(string.Format("{0}{1}", _baseAddress, methodName),
log, HTTPVerbs.POST, dsp);
}
}
private static void WriteLog(LogLevels level, string format, params object[] args)
{
if (level < MinLogLevel)
{
return;
}
string output = string.Format("[{0}] : {1}", level.ToString(), string.Format(format, args));
switch (level)
{
case LogLevels.Debug:
case LogLevels.Activity:
case LogLevels.Info:
case LogLevels.Notice:
if (useDelayedLogging)
{
delayedDebugQueue.Enqueue(output);
}
else
{
UnityEngine.Debug.Log(output);
}
break;
case LogLevels.Warning:
if (useDelayedLogging)
{
delayedWarningQueue.Enqueue(output);
}
else
{
UnityEngine.Debug.LogWarning(output);
}
break;
case LogLevels.Error:
if (useDelayedLogging)
{
delayedErrorQueue.Enqueue(output);
}
else
{
UnityEngine.Debug.LogError(output);
}
break;
}
}
private void EnviarLog(LogLevels logLevel, string className, string memberName, string message, int numberWriteErrors = 3)
{
try
{
string currentDate = DateTime.Now.ToString("dd/MM/yyyy");
string currentTime = DateTime.Now.ToString("HH:mm:ss");
string completeMessage = $"{currentDate}\t{currentTime}\t{Thread.CurrentThread.ManagedThreadId}\t{logLevel.ToString()}\t{className}\t{memberName}\t{message}";
request = new DatosRequest();
//if (HttpContext.Current != null && HttpContext.Current.Request != null)
if (_httpContextAccessor.HttpContext.Request != null)
{
// Rellenar objeto con los datos (Request)
HttpRequest currentRequest = _httpContextAccessor.HttpContext.Request;
IRequestCookieCollection listaCookies = currentRequest.Cookies;
request.CookieSessionId = currentRequest.Cookies["ASP.NET_SessionId"];
string headers = "";
string[] arrayHeaders = currentRequest.Headers.Keys.ToArray();
foreach (string clave in arrayHeaders)
{
currentRequest.Headers.TryGetValue(clave, out StringValues values);
headers += $"{clave} : {string.Join(" ", values)}\n";
}
request.Headers = headers.TrimEnd();
request.HttpMethod = currentRequest.Method;
request.RawURL = currentRequest.GetEncodedUrl();
request.URL = currentRequest.GetDisplayUrl();
request.UserAgent = currentRequest.Headers["User-Agent"];
request.Domain = currentRequest.Host.Value;
if (currentRequest.Body != null && currentRequest.Body.Length > 0)
{
currentRequest.Body.Position = 0;
StreamReader streamInputStream = new StreamReader(currentRequest.Body);
request.Body = streamInputStream.ReadToEnd();
}
string ip = currentRequest.Headers["X-FORWARDED-FOR"];
if (string.IsNullOrEmpty(ip))
{
ip = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress.ToString();
request.Ip = ip;
}
}
// Objeto Anónimo
var data = new { CurrentDate = currentDate, CurrentTime = currentTime, ThreadId = Thread.CurrentThread.ManagedThreadId, LogLevel = logLevel.ToString(), ClassName = className, MemberName = memberName, Message = message };
LOG = new LoggerConfiguration()
.WriteTo.Http(EndPoint)
.CreateLogger();
switch (logLevel)
{
case LogLevels.TRACE:
LOG = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.Http(EndPoint)
.CreateLogger();
LOG.Verbose("{@data}, {@request}", data, request);
break;
case LogLevels.DEBUG:
LOG = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Http(EndPoint)
.CreateLogger();
LOG.Debug("{@data}, {@request}", data, request);
break;
case LogLevels.INFO:
LOG.Information("{@data}, {@request}", data, request);
break;
case LogLevels.WARN:
LOG.Warning("{@data}, {@request}", data, request);
break;
case LogLevels.ERROR:
LOG.Error("{@data}, {@request}", data, request);
break;
case LogLevels.FATAL:
LOG.Fatal("{@data}, {@request}", data, request);
break;
}
Console.WriteLine($"Mensaje Enviado: {completeMessage}");
}
catch
{
Thread.Sleep(500);
if (numberWriteErrors > 0)
{
numberWriteErrors--;
EnviarLog(logLevel, className, memberName, message, numberWriteErrors);
}
}
}
/// <summary>
/// Write a message in the log file
/// </summary>
private void Write(LogLevels logLevel, string className, string memberName, string message, int numberWriteErrors = 3)
{
string currentDate = DateTime.Now.ToString("dd/MM/yyyy");
string currentTime = DateTime.Now.ToString("HH:mm:ss");
string completeMessage = $"{currentDate}\t{currentTime}\t{Thread.CurrentThread.ManagedThreadId}\t{logLevel.ToString()}\t{className}\t{memberName}\t{message}";
if (UtilTelemetry.EstaConfiguradaTelemetria && !LogHelper.LogLocation.Equals(LogsAndTracesLocation.File))
{
try
{
if (logLevel < LogLevels.ERROR)
{
UtilTelemetry.EnviarTelemetriaTraza(completeMessage);
}
else
{
Exception ex = new Exception(completeMessage);
UtilTelemetry.EnviarTelemetriaExcepcion(ex, completeMessage);
}
}
catch
{ }
}
}
