/// <summary> /// Gets the service. /// </summary> /// <param name="service">The service.</param> /// <param name="loggerConfiguration">The logger configuration.</param> /// <returns>The complete service.</returns> internal static Service GetService(Service service, FileLoggerConfiguration loggerConfiguration) { var svcTbl = new SC_StatusDbDt.Service(); string where = string.Empty; if (string.IsNullOrEmpty(service.ServiceName)) { where = string.Format("{0} = {1}", "ServiceId", service.ServiceId); } else { where = string.Format("{0} = '{1}'", "ServiceName", service.ServiceName); } var svc = svcTbl.Single(where : where); return(new Service { ServiceId = (int)svc.ServiceId, ServiceName = svc.ServiceName, ServiceDescription = svc.ServiceDescription, ServiceStatus = (Service.ServiceStatusEnum)((int)svc.ServiceStatus), ServiceDisplayName = svc.ServiceDisplayName, LocationId = (int)svc.LocationId, SystemId = (int)svc.SystemId, ApplicationId = (int)svc.ApplicationId, InstallPath = svc.InstallPath, IsHub = svc.IsHub, ServiceCommands = GetServiceCommands(service, loggerConfiguration) }); }
/// <summary> /// Gets the services. /// </summary> /// <param name="serviceStatusDatabasePath">The service status database path.</param> /// <param name="loggerConfiguration">The logger configuration.</param> /// <returns> /// A generic list of services administered by the hub service. /// </returns> public static List <Service> GetServices(FileLoggerConfiguration loggerConfiguration) { List <Service> services = new List <Service>(); var svcTable = new SC_StatusDbDt.Service(); var svcs = svcTable.All(); foreach (var svc in svcs) { services.Add(new Service { ServiceId = (int)svc.ServiceId, ServiceName = svc.ServiceName, ServiceDescription = svc.ServiceDescription, ServiceStatus = (Service.ServiceStatusEnum)((int)svc.ServiceStatus), ServiceDisplayName = svc.ServiceDisplayName, LocationId = (int)svc.LocationId, SystemId = (int)svc.SystemId, ApplicationId = (int)svc.ApplicationId, InstallPath = svc.InstallPath, IsHub = svc.IsHub, ServiceCommands = GetServiceCommands((int)svc.ServiceId, loggerConfiguration) }); } return(services); }
private FileLogger(FileLoggerConfiguration settings) { Settings = settings; log4net.GlobalContext.Properties["LogName"] = Settings.LogFileName; logger = LogManager.GetLogger(typeof(FileLogger)); XmlConfigurator.Configure(); }
/// <summary> /// Removes the service. /// </summary> public static void RemoveService(Service service, FileLoggerConfiguration loggerConfiguration) { Logging.Log(LogLevelEnum.Info, "Begin Service status removal", loggerConfiguration); Logging.Log(LogLevelEnum.Debug, "Begin SQLite database connection initialization", loggerConfiguration); using (SQLiteConnection sqliteConnection = SQLite.InitializeConnection(service.ServiceStatusDatabasePath, loggerConfiguration)) { sqliteConnection.Open(); Logging.Log(LogLevelEnum.Debug, "SQLite Connection opened", loggerConfiguration); Logging.Log(LogLevelEnum.Info, string.Format("Beginning service status removal:\t\tService name: {0}\t\tService ID: {1}", service.ServiceName, service.ServiceId), loggerConfiguration); string sqlStatement = string.Format("DELETE FROM ServiceCommand where ServiceId = {0}", service.ServiceId); try { SQLite.ExecuteNonQuery(sqlStatement, sqliteConnection, loggerConfiguration); sqlStatement = string.Format("DELETE FROM Service where ServiceId = {0}", service.ServiceId); SQLite.ExecuteNonQuery(sqlStatement, sqliteConnection, loggerConfiguration); } catch (Exception ex) { Logging.Log(LogLevelEnum.Fatal, FileLogger.GetInnerException(ex).Message, loggerConfiguration); Logging.HandleException(ex); throw; } sqliteConnection.Close(); Logging.Log(LogLevelEnum.Debug, "SQLite Connection closed", loggerConfiguration); Logging.Log(LogLevelEnum.Info, string.Format("Service status removal finished:\t\tService name: {0}\t\tService ID: {1}", service.ServiceName, service.ServiceId), loggerConfiguration); } Logging.Log(LogLevelEnum.Info, "End Service status removal", loggerConfiguration); }
public static ILoggerFactory AddFileLogger(this ILoggerFactory loggerFactory, Action <FileLoggerConfiguration> configure) { var config = new FileLoggerConfiguration(); configure(config); return(loggerFactory.AddFileLogger(config)); }
/// <summary> /// Add <seealso cref="FileLoggerProvider"/> with set path and the <seealso cref="FileLoggerConfiguration"/>. /// </summary> /// <param name="builder">The <seealso cref="ILoggingBuilder"/> that adds the <seealso cref="FileLoggerProvider"/>.</param> /// <param name="path">The path of the log file.</param> /// <param name="configuration">The configuration for the <seealso cref="FileLogger"/>.</param> /// <returns></returns> public static ILoggingBuilder AddFile(this ILoggingBuilder builder, string path, FileLoggerConfiguration configuration = null) { configuration ??= new FileLoggerConfiguration(); builder.AddProvider(new FileLoggerProvider(path, configuration)); return(builder); }
public void Test_FileLogger_Default() { var fileLoggerConfiguration = new FileLoggerConfiguration(); var fileLogger = LogSettings.RegisterDefaultLogger <FileLogger>(fileLoggerConfiguration); Assert.Equal(fileLoggerConfiguration.FilenamePattern, fileLogger.FilenamePattern); Assert.Equal(fileLogger, LogSettings.DefaultLogger); }
/// <summary> /// Is used to configure and register file logger /// </summary> /// <param name="fileLoggerConfiguration">file logger configuration</param> /// <param name="loggerConfiguration">applications main (serilog) logger configuration</param> private static void RegisterFileLogger(FileLoggerConfiguration fileLoggerConfiguration, LoggerConfiguration loggerConfiguration) { if (fileLoggerConfiguration.Enabled) { string path = fileLoggerConfiguration.IsGlobalPath ? fileLoggerConfiguration.Path : Path.Combine(ApplicationEnvironment.ApplicationBasePath, fileLoggerConfiguration.Path); LogEventLevel fileLogLvl = (LogEventLevel)Enum.Parse(typeof(LogEventLevel), fileLoggerConfiguration.Level); loggerConfiguration.WriteTo.RollingFile(path, fileLogLvl, fileSizeLimitBytes: fileLoggerConfiguration.FileSizeLimitBytes, retainedFileCountLimit: fileLoggerConfiguration.RetainedFileCountLimit); } }
public static FileLogger Instance(FileLoggerConfiguration settings) { if (string.IsNullOrEmpty(settings.LogFileName)) { settings.LogFileName = FileLoggerConfiguration.DefaultLogFileName; } instance = new FileLogger(settings); return(instance); }
public static SQLiteConnection InitializeConnection(string databasePath, FileLoggerConfiguration loggerConfiguration) { SQLiteConnectionStringBuilder sqliteConnectionStringBuilder = new SQLiteConnectionStringBuilder { DataSource = databasePath, PageSize = 1024, Pooling = true }; Logging.Log(LogLevelEnum.Debug, "SQLite Connection string initialized", loggerConfiguration); Logging.Log(LogLevelEnum.Debug, string.Format("Connection string: {0}", sqliteConnectionStringBuilder.ConnectionString), loggerConfiguration); return(new SQLiteConnection(sqliteConnectionStringBuilder.ConnectionString)); }
public static void ExecuteNonQuery(SQLiteCommand sqliteCommand, FileLoggerConfiguration loggerConfiguration) { try { using (sqliteCommand) { sqliteCommand.CommandType = CommandType.Text; Logging.Log(LogLevelEnum.Debug, string.Format("SQL statement:\n\n{0}\n\n", sqliteCommand.CommandText), loggerConfiguration); sqliteCommand.ExecuteNonQuery(); } } catch (Exception ex) { StackTrace stackTrace = new StackTrace(); Logging.Log(LogLevelEnum.Error, string.Format("{0}: {1}", stackTrace.GetFrame(1).GetMethod().Name, FileLogger.GetInnerException(ex).Message), loggerConfiguration); Logging.HandleException(ex); } }
/// <summary> /// Initializes the service. /// </summary> /// <param name="service">The service.</param> /// <returns>The service ID</returns> public static int InitializeService(Service service, FileLoggerConfiguration loggerConfiguration) { Logging.Log(LogLevelEnum.Info, "Begin Service status initialization", loggerConfiguration); int serviceId = -1; Logging.Log(LogLevelEnum.Debug, "Begin SQLite database connection initialization", loggerConfiguration); using (SQLiteConnection sqliteConnection = SQLite.InitializeConnection(service.ServiceStatusDatabasePath, loggerConfiguration)) { sqliteConnection.Open(); Logging.Log(LogLevelEnum.Debug, "SQLite Connection opened", loggerConfiguration); serviceId = InitializeService(service, sqliteConnection, loggerConfiguration); sqliteConnection.Close(); Logging.Log(LogLevelEnum.Debug, "SQLite Connection closed", loggerConfiguration); } return(serviceId); }
/// <summary> /// Gets the service status. /// </summary> /// <param name="service">The service.</param> /// <returns>The service status.</returns> public static Service.ServiceStatusEnum GetServiceStatus(Service service, FileLoggerConfiguration loggerConfiguration) { return(GetServiceStatus(service.ServiceId, loggerConfiguration)); }
/// <summary> /// Gets the service status. /// </summary> /// <param name="serviceId"></param> /// <returns>The service status.</returns> public static Service.ServiceStatusEnum GetServiceStatus(int serviceId, FileLoggerConfiguration loggerConfiguration) { return(GetService(serviceId, loggerConfiguration).ServiceStatus); }
/// <summary> /// Sets the service status. /// </summary> /// <param name="serviceStatus"></param> /// <param name="serviceId"></param> public static void SetStatus(Service.ServiceStatusEnum serviceStatus, int serviceId, FileLoggerConfiguration loggerConfiguration) { var svcTable = new SC_StatusDbDt.Service(); svcTable.Update(new { ServiceStatus = (int)serviceStatus }, serviceId); }
/// <summary> /// Sets the service status. /// </summary> /// <param name="service">The service.</param> public static void SetStatus(Service service, FileLoggerConfiguration loggerConfiguration) { SetStatus(service.ServiceStatus, service.ServiceId, loggerConfiguration); }
public static SQLiteDataReader ExecuteReader(string sqlStatement, SQLiteConnection sqliteConnection, FileLoggerConfiguration loggerConfiguration) { SQLiteDataReader reader = null; try { using (SQLiteCommand cmd = new SQLiteCommand(sqlStatement, sqliteConnection)) { cmd.CommandType = CommandType.Text; Logging.Log(LogLevelEnum.Debug, string.Format("SQL statement:\n\n{0}\n\n", sqlStatement), loggerConfiguration); reader = cmd.ExecuteReader(); } } catch (Exception ex) { StackTrace stackTrace = new StackTrace(); Logging.Log(LogLevelEnum.Error, string.Format("{0}: {1}", stackTrace.GetFrame(1).GetMethod().Name, FileLogger.GetInnerException(ex).Message), loggerConfiguration); Logging.HandleException(ex); } return(reader); }
/// <summary> /// Creates the database. This is the method used by the hub set up. /// </summary> /// <returns>The service ID for the hub.</returns> public static int CreateDatabase(Service service, List <string> serviceStatusDbSetupSql, FileLoggerConfiguration loggerConfiguration) { int serviceId = -1; if (!File.Exists(service.ServiceStatusDatabasePath)) { Logging.Log(LogLevelEnum.Info, "Begin SQLite database initialization", loggerConfiguration); var db = new SC_StatusDbDt.Service(); Logging.Log(LogLevelEnum.Debug, "Begin SQL statements", loggerConfiguration); foreach (var sqlStatement in serviceStatusDbSetupSql) { try { db.Execute(sqlStatement, new object[0]); } catch (Exception ex) { Logging.Log(LogLevelEnum.Fatal, FileLogger.GetInnerException(ex).Message, loggerConfiguration); Logging.HandleException(ex); throw; } } Logging.Log(LogLevelEnum.Debug, "End SQL statements", loggerConfiguration); serviceId = DatabaseInstaller.InitializeService(service, null, loggerConfiguration); Logging.Log(LogLevelEnum.Info, "End SQLite database initialization", loggerConfiguration); } return(serviceId); }
private static List <LogRecord> Parse(LogLevelEnum logLevel, FileLoggerConfiguration configuration) { FileLogger fileLogger = FileLogger.Instance(configuration); return(fileLogger.Parse(logLevel)); }
/// <summary> /// Updates the service monitor. /// </summary> /// <param name="service">The service.</param> /// <param name="serviceStatusDatabasePath">The service status database path.</param> public static void UpdateServiceMonitor(Service service, string serviceStatusDatabasePath, FileLoggerConfiguration loggerConfiguration) { var svcMon = new SC_StatusDbDt.ServiceMonitor(); if (svcMon.Count(string.Format("ServiceId = {0}", service.ServiceId)) > 0) { svcMon.Update(new { MonitorTime = DateTime.Now }, new { ServiceId = service.ServiceId }); } else { svcMon.Insert(new { MonitorTime = DateTime.Now, ServiceId = service.ServiceId }); } }
/// <summary> /// Initializes the service. /// </summary> /// <param name="service">The service.</param> /// <param name="sqliteConnection">The sqlite connection.</param> /// <returns>The service ID</returns> internal static int InitializeService(Service service, SQLiteConnection sqliteConnection, FileLoggerConfiguration loggerConfiguration) { Logging.Log(LogLevelEnum.Info, string.Format("Beginning service status initialization:\n\t\tService name: {0}", service.ServiceName), loggerConfiguration); var svcTbl = new SC_StatusDbDt.Service(); var newId = svcTbl.Insert(new { ServiceName = service.ServiceName, ServiceDescription = service.ServiceDescription, ServiceDisplayName = service.ServiceDisplayName, LocationId = service.LocationId, ApplicationId = service.ApplicationId, SystemId = service.SystemId, InstallPath = service.InstallPath, ServiceStatus = (int)Service.ServiceStatusEnum.Stopped, IsHub = service.IsHub }); service = DatabaseController.GetService(service, loggerConfiguration); Logging.Log(LogLevelEnum.Info, string.Format("Service status initialization finished:\n\t\tService name: {0}\n\t\tService ID: {1}", service.ServiceName, service.ServiceId), loggerConfiguration); return(service.ServiceId); }
/// <summary> /// Gets the service commands. /// </summary> /// <param name="serviceId">The service id.</param> /// <param name="loggerConfiguration">The logger configuration.</param> /// <returns></returns> public static List <ServiceCommandStruct> GetServiceCommands(int serviceId, FileLoggerConfiguration loggerConfiguration) { return(GetServiceCommands(new Service { ServiceId = serviceId }, loggerConfiguration)); }
/// <summary> /// Gets the service. /// </summary> /// <param name="serviceId">The service id.</param> /// <param name="loggerConfiguration">The logger configuration.</param> /// <returns></returns> internal static Service GetService(int serviceId, FileLoggerConfiguration loggerConfiguration) { return(GetService(new Service { ServiceId = serviceId }, loggerConfiguration)); }
public static void ExecuteNonQuery(SQLiteCommand sqliteCommand, SQLiteConnection sqliteConnection, FileLoggerConfiguration loggerConfiguration) { try { using (sqliteCommand) { sqliteCommand.Connection = sqliteConnection; ExecuteNonQuery(sqliteCommand, loggerConfiguration); } } catch (Exception ex) { StackTrace stackTrace = new StackTrace(); Logging.Log(LogLevelEnum.Error, string.Format("{0}: {1}", stackTrace.GetFrame(1).GetMethod().Name, FileLogger.GetInnerException(ex).Message), loggerConfiguration); Logging.HandleException(ex); } }
public static void Log(LogLevelEnum logLevel, string message, FileLoggerConfiguration configuration) { FileLogger fileLogger = FileLogger.Instance(configuration); fileLogger.WriteLog(logLevel, message); }
/// <summary> /// Gets the service monitor time. /// </summary> /// <param name="service">The service.</param> /// <param name="serviceStatusDatabasePath">The service status database path.</param> /// <returns></returns> public static DateTime GetServiceMonitorTime(Service service, string serviceStatusDatabasePath, FileLoggerConfiguration loggerConfiguration) { DateTime returnTime = new DateTime(); var svcMon = new SC_StatusDbDt.ServiceMonitor(); var monitorTime = svcMon.Single(new { ServiceId = service.ServiceId }); returnTime = monitorTime.MonitorTime; return(returnTime); }
private static List <LogRecord> Parse(FileLoggerConfiguration configuration) { FileLogger fileLogger = FileLogger.Instance(configuration); return(fileLogger.Parse()); }
/// <summary> /// Sets the extension success status. /// </summary> /// <param name="serviceId">The service id.</param> /// <param name="success">if set to <c>true</c> [success].</param> /// <param name="serviceStatusDatabasePath">The service status database path.</param> public static void SetExtensionSuccessStatus(int serviceId, bool success, string serviceStatusDatabasePath, FileLoggerConfiguration loggerConfiguration) { var svcMon = new SC_StatusDbDt.ServiceMonitor(); dynamic data = new { }; if (svcMon.Count(string.Format("ServiceId = {0}", serviceId)) > 0) { if (success) { data = new { ServiceSuccessRunTime = DateTime.Now }; } else { data = new { ServiceFailRunTime = DateTime.Now }; } svcMon.Update(data, new { ServiceId = serviceId }); } else { if (success) { data = new { ServiceSuccessRunTime = DateTime.Now, ServiceId = serviceId }; } else { data = new { ServiceFailRunTime = DateTime.Now, ServiceId = serviceId }; } svcMon.Insert(data); } }
/// <summary> /// Gets the service commands. /// </summary> /// <param name="service">The service.</param> /// <returns>A generic list of ServiceCommandStruct</returns> public static List <ServiceCommandStruct> GetServiceCommands(Service service, FileLoggerConfiguration loggerConfiguration) { var svcTable = new SC_StatusDbDt.ServiceCommand(); var svcCommands = svcTable.All(where : string.Format("ServiceId = {0}", service.ServiceId)); List <ServiceCommandStruct> tempCommands = new List <ServiceCommandStruct>(); foreach (var command in svcCommands) { tempCommands.Add(new ServiceCommandStruct { CommandId = command.CommandId, CommandDescription = command.CommandDescription }); } return(tempCommands); }
/// <summary> /// Gets the extension execute status time. /// </summary> /// <param name="service">The service.</param> /// <param name="success">if set to <c>true</c> [success].</param> /// <param name="serviceStatusDatabasePath">The service status database path.</param> /// <returns></returns> public static DateTime GetExtensionExecuteStatusTime(Service service, bool success, string serviceStatusDatabasePath, FileLoggerConfiguration loggerConfiguration) { DateTime returnTime = DateTime.MinValue; var svcMon = new SC_StatusDbDt.ServiceMonitor(); var monitorTime = svcMon.Single(new { ServiceId = service.ServiceId }); if (success) { returnTime = monitorTime.ServiceSuccessRunTime; } else { returnTime = monitorTime.ServiceFailRunTime; } return(returnTime); }