static LoadingAdjustedTimestamp()
{
Reset();
Log = Logger.CreatePublisher(typeof(LoadingAdjustedTimestamp), MessageClass.Component);
LogLoadingClock = Log.RegisterEvent(MessageLevel.Info, MessageFlags.SystemHealth, $"Loading Clock is behind", 0, MessageRate.EveryFewSeconds(1), 1);
LogSmall = Log.RegisterEvent(MessageLevel.Info, MessageFlags.SystemHealth, $"Short High Load Condition Detected", 0, MessageRate.EveryFewSeconds(10), 5);
LogMedium = Log.RegisterEvent(MessageLevel.Warning, MessageFlags.SystemHealth, $"Medium High Load Condition Detected", 0, MessageRate.EveryFewSeconds(10), 5);
LogLarge = Log.RegisterEvent(MessageLevel.Error, MessageFlags.SystemHealth, $"Long High Load Condition Detected", 0, MessageRate.EveryFewSeconds(10), 5);
LogLoadingClock.ShouldRaiseMessageSupressionNotifications = false;
LogSmall.ShouldRaiseMessageSupressionNotifications = false;
LogMedium.ShouldRaiseMessageSupressionNotifications = false;
LogLarge.ShouldRaiseMessageSupressionNotifications = false;
MonitorHighThread = new Thread(MonitorHighPriority, short.MaxValue);
MonitorHighThread.Priority = ThreadPriority.Highest;
MonitorHighThread.IsBackground = true;
MonitorHighThread.Start();
MonitorNormalThread = new Thread(MonitorNormalPriority, short.MaxValue);
MonitorNormalThread.Priority = ThreadPriority.Normal;
MonitorNormalThread.IsBackground = true;
MonitorNormalThread.Start();
MonitorLowThread = new Thread(MonitorLowPriority, short.MaxValue);
MonitorLowThread.Priority = ThreadPriority.Lowest;
MonitorLowThread.IsBackground = true;
MonitorLowThread.Start();
}
/// <summary>
/// Creates a new <see cref="HistorianDataWalker"/>.
/// </summary>
public HistorianDataWalker()
{
InitializeComponent();
// Create a new log publisher instance
m_log = Logger.CreatePublisher(typeof(HistorianDataWalker), MessageClass.Application);
}
private static void OnChatLogItemReceived(object sender, ChatLogItemEvent chatLogItemEvent)
{
// delegate event from chat log, not required to subsribe
// this updates 100 times a second and only sends a line when it gets a new one
if (sender == null)
{
return;
}
ChatLogItem chatLogEntry = chatLogItemEvent.ChatLogItem;
Logging.Log(Logger, new LogItem(chatLogItemEvent.ChatLogItem.Code));
Logging.Log(Logger, new LogItem(chatLogItemEvent.ChatLogItem.Bytes.ToString()));
Logging.Log(Logger, new LogItem(chatLogItemEvent.ChatLogItem.Combined));
Logging.Log(Logger, new LogItem(chatLogItemEvent.ChatLogItem.Line));
Logging.Log(Logger, new LogItem(chatLogItemEvent.ChatLogItem.Raw));
Logging.Log(Logger, new LogItem(chatLogItemEvent.ChatLogItem.TimeStamp.ToString("o")));
try
{
LogPublisher.Process(chatLogEntry);
}
catch (Exception ex) {
Logging.Log(Logger, new LogItem(ex, true));
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
FileLogSubscriber sub = new FileLogSubscriber();
sub.InitializeSubscription();
//Task.Run(() => {
// FileLogSubscriber sub = new FileLogSubscriber();
//});
//Task.Run(() => {
// LogPublisher pub = new LogPublisher();
// pub.PublishLog(new EventType.Data.FileLoggerMessage { });
//});
var message = new FileLoggerMessage();
LogPublisher pub = new LogPublisher();
while (true)
{
Console.WriteLine("Enter Title:>>>");
message.Title = Console.ReadLine();
Console.WriteLine("Enter Description:>>>");
message.Detail = Console.ReadLine();
pub.PublishLog(message);
Console.WriteLine("\n-------------------------------------------------------\n");
}
Console.ReadLine();
}
/// <summary>
/// Creates a new <see cref="BenchmarkBerkeleyDB"/>.
/// </summary>
public BenchmarkBerkeleyDB()
{
InitializeComponent();
// Create a new log publisher instance
m_log = Logger.CreatePublisher(typeof(BenchmarkBerkeleyDB), MessageClass.Application);
}
internal SharedTimer(SharedTimerScheduler scheduler, int interval = 100)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
if (scheduler.IsDisposed)
{
throw new ArgumentException("Scheduler has been disposed", nameof(scheduler));
}
if (interval <= 0)
{
throw new ArgumentOutOfRangeException(nameof(interval));
}
m_log = Logger.CreatePublisher(typeof(SharedTimerScheduler), MessageClass.Component);
m_scheduler = scheduler;
m_interval = interval;
m_enabled = false;
m_autoReset = true;
m_callback = TimerCallback;
m_scheduler = scheduler;
}
public BulkCalculationState()
{
InitializeComponent();
// Create a new log publisher instance
m_log = Logger.CreatePublisher(typeof(BulkCalculationState), MessageClass.Application);
}
// called during Verse.Mod instantiation
private void InitializeController()
{
try {
ReadOwnVersion();
Logger.Message("version {0}", LibraryVersion);
PrepareReflection();
ApplyHarmonyPatches();
Settings = new ModSettingsManager();
Settings.BeforeModSettingsSaved += OnBeforeModSettingsSaved;
UpdateFeatures = new UpdateFeatureManager();
UpdateFeatures.OnEarlyInitialize();
TickDelayScheduler = new TickDelayScheduler();
DistributedTicker = new DistributedTickScheduler();
DoLater = new DoLaterScheduler();
LogUploader = new LogPublisher();
var librarySettings = Settings.GetModSettings(ModIdentifier);
QuickstartController.OnEarlyInitialize(librarySettings);
ModSpotter = new ModSpottingManager();
ModSpotter.OnEarlyInitialize();
new LibraryVersionChecker(LibraryVersion, Logger).OnEarlyInitialize();
LoadOrderChecker.ValidateLoadOrder();
EnumerateModAssemblies();
EarlyInitializeChildMods();
} catch (Exception e) {
Logger.ReportException(e);
}
}
public Main()
{
InitializeComponent();
// Create a new log publisher instance
m_log = Logger.CreatePublisher(typeof(Main), MessageClass.Application);
}
public MainForm()
{
InitializeComponent();
// Create a new log publisher instance
m_log = Logger.CreatePublisher(typeof(MainForm), MessageClass.Application);
m_initialShow = true;
}
static Logger()
{
lock (Sync)
{
LogPublisher = new LogPublisher();
Debug = new DebugLogger();
}
}
private ProcessClient(CtpServer server, TcpClient client)
{
using (Logger.AppendStackMessages("Remote Client", client.Client.RemoteEndPoint.ToString()))
Log = Logger.CreatePublisher(typeof(ProcessClient), MessageClass.Framework);
m_server = server;
m_client = client;
}
static Logger()
{
lock (sync)
{
logPublisher = new LogPublisher();
moduleManager = new ModuleManager();
debugLogger = new DebugLogger();
}
}
private static void Main(string[] args)
{
string localPath = FilePath.GetAbsolutePath("");
string logPath = string.Format("{0}{1}Logs{1}", localPath, Path.DirectorySeparatorChar);
try
{
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
}
catch
{
logPath = localPath;
}
Logger.FileWriter.SetPath(logPath);
Logger.FileWriter.SetLoggingFileCount(10);
Logger.SuppressFirstChanceExceptionLogMessages();
// Create a new log publisher instance
Log = Logger.CreatePublisher(typeof(MainForm), MessageClass.Application);
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
IConfiguration configuration = new ConfigurationBuilder()
.ConfigureGemstoneDefaults(Settings.ConfigureAppSettings, useINI: true)
.AddCommandLine(args, Settings.SwitchMappings)
.Build();
Settings settings = new(configuration);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
try
{
Application.Run(new MainForm {
Settings = settings
});
}
catch (Exception ex)
{
Log.Publish(MessageLevel.Error, "Application", "Unhandled Application Exception", exception: ex);
}
try
{
settings.Save();
}
catch (Exception ex)
{
Log.Publish(MessageLevel.Error, "Application", "Save Settings Exception", exception: ex);
}
}
/// <summary>
/// Creates a new instance of the <see cref="SharedTimerScheduler"/> class.
/// </summary>
public SharedTimerScheduler()
{
m_syncRoot = new object();
m_log = Logger.CreatePublisher(typeof(SharedTimerScheduler), MessageClass.Component);
m_schedulesByInterval = new Dictionary <int, SharedTimerInstance>();
m_reportStatus = new ScheduledTask();
m_reportStatus.Running += ReportStatus;
m_reportStatus.Start(60 * 1000);
}
static Logger()
{
lock (Sync)
{
LogPublisher = new LogPublisher();
ModuleManager = new ModuleManager();
DebugLogger = new DebugLogger();
}
}
private static void Error1(LogPublisher pub2)
{
try
{
int value = int.Parse("dk20");
}
catch (Exception ex)
{
pub2.Publish(MessageLevel.Critical, "Failed Cast", null, null, ex);
}
}
/// <summary>
/// Listen for a socket connection
/// </summary>
public CtpServer(IPEndPoint listenEndpoint, IServerAuthentication config)
{
m_config = config;
m_listenEndpoint = listenEndpoint ?? throw new ArgumentNullException(nameof(listenEndpoint));
m_onAccept = OnAccept;
var logMessages = new LogStackMessages("Listen Port", listenEndpoint.ToString());
using (Logger.AppendStackMessages(logMessages))
Log = Logger.CreatePublisher(typeof(CtpServer), MessageClass.Framework);
}
private void RegisterOwnSettings()
{
try {
var pack = Settings.GetModSettings(ModIdentifier);
pack.EntryName = assemblyContentPacks[Assembly.GetCallingAssembly()]?.Name ?? "HugsLib";
pack.DisplayPriority = ModSettingsPack.ListPriority.Lowest;
pack.AlwaysExpandEntry = true;
UpdateFeatures.RegisterSettings(pack);
LogPublisher.RegisterSettings(pack);
} catch (Exception e) {
Logger.ReportException(e);
}
}
private static int Main()
{
string localPath = FilePath.GetAbsolutePath("");
string logPath = string.Format("{0}{1}Logs{1}", localPath, Path.DirectorySeparatorChar);
try
{
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
}
catch
{
logPath = localPath;
}
Logger.FileWriter.SetPath(logPath);
Logger.FileWriter.SetLoggingFileCount(10);
Logger.SuppressFirstChanceExceptionLogMessages();
Log = Logger.CreatePublisher(typeof(Program), MessageClass.Application);
Log.Publish(MessageLevel.Info, "ApplicationStart");
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
try
{
using (AdoDataConnection database = Program.GetDatabaseConnection())
{
if (database is null)
{
throw new InvalidOperationException("No configured database connection string and data provider string found.");
}
}
}
catch (Exception ex)
{
Log.Publish(MessageLevel.Error, "Database Connection", exception: ex);
MessageBox.Show($"Failed to connect to database defined in \"{Program.HostConfigFileName}\":{Environment.NewLine}{ex.Message}", "Database Connection Error", MessageBoxButtons.OK);
return((int)ExitCode.DatabaseConnectFailure);
}
AdapterExplorerApplication app = new AdapterExplorerApplication();
app.Run(Environment.GetCommandLineArgs());
return((int)ExitCode.Success);
}
private void RegisterOwnSettings()
{
try {
var pack = Settings.GetModSettings(ModIdentifier);
pack.EntryName = "HugsLib_ownSettingsName".Translate();
pack.DisplayPriority = ModSettingsPack.ListPriority.Lowest;
pack.AlwaysExpandEntry = true;
UpdateFeatures.RegisterSettings(pack);
QuickstartController.RegisterSettings(pack);
LogPublisher.RegisterSettings(pack);
} catch (Exception e) {
Logger.ReportException(e);
}
}
public MainForm()
{
InitializeComponent();
m_log = Program.Log;
m_messages = new StringBuilder();
m_appendOutputMessages = new ShortSynchronizedOperation(AppendOutputMessages,
ex => m_log.Publish(MessageLevel.Error, "AppendOutput", "Append Output Message Exception", exception: ex));
#if DEBUG
m_debugBuild = true;
#else
m_debugBuild = false;
#endif
}
// called during Verse.Mod instantiation
private void InitializeController()
{
try {
PrepareReflection();
ApplyHarmonyPatches();
Settings = new ModSettingsManager(OnSettingsChanged);
UpdateFeatures = new UpdateFeatureManager();
TickDelayScheduler = new TickDelayScheduler();
DistributedTicker = new DistributedTickScheduler();
LogUploader = new LogPublisher();
ReadOwnVersionFile();
LoadOrderChecker.ValidateLoadOrder();
} catch (Exception e) {
Logger.ReportException(e);
}
}
private static void OnNewChatLogEntry(object sender, ChatLogEntryEvent chatLogEntryEvent)
{
// delegate event from chat log, not required to subsribe
// this updates 100 times a second and only sends a line when it gets a new one
if (sender == null)
{
return;
}
var chatLogEntry = chatLogEntryEvent.ChatLogEntry;
try
{
LogPublisher.Process(chatLogEntry);
}
catch (Exception ex)
{
}
}
static ShutdownHandler()
{
s_syncRoot = new object();
s_onShutdownCallbackFirst = new List <WeakAction>();
s_onShutdownCallbackDefault = new List <WeakAction>();
s_onShutdownCallbackLast = new List <WeakAction>();
Logger.Initialize();
Log = Logger.CreatePublisher(typeof(ShutdownHandler), MessageClass.Component);
if (AppDomain.CurrentDomain.IsDefaultAppDomain())
{
AppDomain.CurrentDomain.ProcessExit += InitiateSafeShutdown;
}
else
{
AppDomain.CurrentDomain.DomainUnload += InitiateSafeShutdown;
}
}
private static void OnChatLogItemReceived(object sender, ChatLogItemEvent chatLogItemEvent)
{
// delegate event from chat log, not required to subsribe
// this updates 100 times a second and only sends a line when it gets a new one
if (sender == null)
{
return;
}
ChatLogItem chatLogItem = chatLogItemEvent.ChatLogItem;
try {
LogPublisher.Process(chatLogItem);
}
catch (Exception ex) {
Logging.Log(Logger, new LogItem(ex, true));
}
}
public MainForm()
{
InitializeComponent();
dataGridViewDevices.AutoGenerateColumns = true;
// Save string format of select count label in its tag
labelSelectCount.Tag = labelSelectCount.Text;
labelSelectCount.Text = "";
// Save string format of filter expression text box in its tag
textBoxFilterExpression.Tag = textBoxFilterExpression.Text;
textBoxFilterExpression.Text = "";
// Create a new log publisher instance
m_log = Logger.CreatePublisher(typeof(MainForm), MessageClass.Application);
//m_graphData = new GraphData();
}
private void PluginHostOnNewChatLogEntry(object sender, ChatLogEntryEvent chatLogEntryEvent)
{
// delegate event from chat log, not required to subsribe
// this updates 100 times a second and only sends a line when it gets a new one
if (sender == null)
{
return;
}
var chatLogEntry = chatLogEntryEvent.ChatLogEntry;
try
{
LogPublisher.Process(chatLogEntry);
}
catch (Exception ex)
{
//Logging.Log(LogManager.GetCurrentClassLogger(), "", ex);
Notice = ex.Message;
}
}
// called during Verse.Mod instantiation
private void InitializeController()
{
try {
ReadOwnVersion();
Logger.Message("version {0}", LibraryVersion);
PrepareReflection();
ApplyHarmonyPatches();
Settings = new ModSettingsManager(OnSettingsChanged);
UpdateFeatures = new UpdateFeatureManager();
TickDelayScheduler = new TickDelayScheduler();
DistributedTicker = new DistributedTickScheduler();
DoLater = new DoLaterScheduler();
LogUploader = new LogPublisher();
LoadOrderChecker.ValidateLoadOrder();
EnumerateModAssemblies();
EarlyInitializeChildMods();
} catch (Exception e) {
Logger.ReportException(e);
}
}
public void Will_send_data_through_log_publisher_at_the_end_of_the_pipeline()
{
string filePath = "path";
Transaction transaction = new() { To = new Address("0x92A3c5e7Cee811C3402b933A6D43aAF2e56f2823") };
IFileSystem fileSystemSub = Substitute.For <IFileSystem>();
fileSystemSub.File.Exists(filePath).Returns(true);
fileSystemSub.File.ReadLines(filePath).Returns(new[] { "0x92A3c5e7Cee811C3402b933A6D43aAF2e56f2823" });
var sourceElement = new TxPoolPipelineSource <Transaction>(_txPool);
var element = new TxPoolPipelineElement <Transaction, Transaction>();
var publisher = new LogPublisher <Transaction, Transaction>(Substitute.For <IJsonSerializer>(), Substitute.For <ILogManager>(), fileSystemSub);
var builder = new PipelineBuilder <Transaction, Transaction>(sourceElement);
builder.AddElement(element).AddElement(publisher);
var pipeline = builder.Build();
_txPool.NewPending += Raise.EventWith(new object(), new TxEventArgs(transaction));
fileSystemSub.Received().File.AppendAllText(filePath, "0x92A3c5e7Cee811C3402b933A6D43aAF2e56f2823");
}
