public void OnTraceEvent(TraceEventArgs e)
{
if (TraceEvent != null)
{
TraceEvent(this, e);
}
}
void connection_Trace(object sender, TraceEventArgs e)
{
if (SQLiteMapper.DefaultLogLevel >= SQLiteMapperLogLevel.SqlTrace)
{
Debug.WriteLine("SQL: " + e.Statement);
}
}
private void OnOpcLibraryTrace(object sender, TraceEventArgs e)
{
try
{
var mask = OPCTraceMask;
if (mask == 0 || ((e.TraceMask & mask) != 0))
{
string output;
if (e.Arguments != null)
{
try
{
output = String.Format(CultureInfo.InvariantCulture, e.Format, e.Arguments);
}
catch
{
output = e.Format;
}
}
else
{
output = e.Format;
}
if (!string.IsNullOrEmpty(e.Message))
{
output = $"{e.Message}: {output}";
}
TheBaseAssets.MySYSLOG.WriteToLog(78008, TSM.L(eDEBUG_LEVELS.OFF) ? null : new TSM(MyBaseThing.EngineName, $"OPC Trace: {e.TraceMask:X04} - {output}", e.Exception != null ? eMsgLevel.l1_Error : eMsgLevel.l6_Debug, e.Exception?.ToString()));
}
}
catch (Exception ex)
{
TheBaseAssets.MySYSLOG.WriteToLog(78008, TSM.L(eDEBUG_LEVELS.OFF) ? null : new TSM(MyBaseThing.EngineName, $"OPC Client Library Trace: Error processing event", eMsgLevel.l1_Error, ex.ToString()));
}
}
private void OnTraceEventInternal(object sender, TraceEventArgs e)
{
// we are using CommandBegin as a "heartbeat" to check if the trace
// has started capturing events
if (!_traceStarted)
{
StopTimer();
_traceStarted = true;
Status = QueryTraceStatus.Started;
if (TraceStarted != null)
{
TraceStarted(this, new TraceStartedEventArgs());
}
}
else
{
OnTraceEvent(e);
if (e.EventClass == TraceEventClass.QueryEnd)
{
//Stop();
if (TraceCompleted != null)
{
TraceCompleted(this, null);
}
}
}
}
public void Add(TraceEventArgs e)
{
if (_procedureContext.ExecutionMode == ProcedureExecutionMode.Live)
{
if (_procedureContext.TraceEventsThreshold > 0 && _traces.Count >= _procedureContext.TraceEventsThreshold)
{
throw new ApplicationException("The maximum number of trace events [{0}] has been reached.{1}Please raise the value of the 'Events number threshold' parameter or execute ASQA Batch Mode analysis.".FormatWith(_procedureContext.TraceEventsThreshold, Environment.NewLine));
}
}
lock (_traces)
{
_traces.Add(e);
}
_synchronizer.Add(e.CurrentTime);
if (++_collectCount >= BatchHelper.BulkCopyBatchSize)
{
_collectCount = 0;
if (_procedureContext.ExecutionMode == ProcedureExecutionMode.Batch)
{
FlushBatch();
}
}
if (e.EventClass == TraceEventClass.ResourceUsage)
{
CollectCompleted.Set();
}
}
private int HandleReceivedData(int bytes, byte[] buff, string sender)
{
BytesReceived += (uint)bytes;
if (this.IsSynchronous)
{
TraceEventArgs arg;
lock (syncBase.receivedSync)
{
int index = syncBase.receivedSize;
syncBase.AppendData(buff, 0, bytes);
if (bytes != 0 && Trace == TraceLevel.Verbose && m_OnTrace != null)
{
arg = new TraceEventArgs(TraceTypes.Received, buff, 0, bytes, null);
m_OnTrace(this, arg);
}
if (bytes != 0 && Eop != null) //Search Eop if given.
{
if (Eop is Array)
{
foreach (object eop in (Array)Eop)
{
bytes = Gurux.Common.GXCommon.IndexOf(syncBase.m_Received, Gurux.Common.GXCommon.GetAsByteArray(eop), index, syncBase.receivedSize);
if (bytes != -1)
{
break;
}
}
}
else
{
bytes = Gurux.Common.GXCommon.IndexOf(syncBase.m_Received, Gurux.Common.GXCommon.GetAsByteArray(Eop), index, syncBase.receivedSize);
}
}
if (bytes != -1)
{
syncBase.receivedEvent.Set();
}
}
}
else
{
if (m_OnReceived != null)
{
syncBase.receivedSize = 0;
byte[] data = new byte[bytes];
Array.Copy(buff, data, bytes);
if (Trace == TraceLevel.Verbose && m_OnTrace != null)
{
m_OnTrace(this, new TraceEventArgs(TraceTypes.Received, data, null));
}
m_OnReceived(this, new ReceiveEventArgs(data, sender));
}
else if (Trace == TraceLevel.Verbose && m_OnTrace != null)
{
m_OnTrace(this, new TraceEventArgs(TraceTypes.Received, buff, 0, bytes, null));
}
}
return(bytes);
}
/// <summary>
/// Log to logger
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Tracing_TraceEventHandler(object sender, TraceEventArgs e)
{
if (!string.IsNullOrEmpty(e.Format) &&
ShouldLog(e.TraceMask, out var level, out var traceName))
{
Logger.Write(level, e.Exception, $"({traceName}) {e.Format}", e.Arguments);
}
}
public MyTraceEventArgs(TraceEventArgs args)
{
EventClass = args.EventClass;
EventSubclass = args.EventSubclass;
DatabaseName = args.DatabaseName;
ObjectPath = args.ObjectPath;
TextData = args.TextData;
}
public MyTraceEventArgs(TraceEventArgs args)
{
EventClass = args.EventClass;
DatabaseName = args.DatabaseName;
ObjectPath = args.ObjectPath;
TextData = args.TextData;
SessionIdOrSpid = args.SessionID;
}
public void Communicator_TraceHandler(object sender, TraceEventArgs ea)
{
ea.ForceDebug = ForceDebug;
if (this.TraceHandler != null)
{
this.TraceHandler(sender, ea);
}
}
/// <summary>
/// Allows writing on the trace log.
/// </summary>
/// <param name="message"></param>
public void WriteToTrace(string message)
{
TraceEventArgs traceArgs = new TraceEventArgs(message, System.Diagnostics.TraceLevel.Info);
if (this.Trace != null)
{
this.Trace(this, traceArgs);
}
}
private void MediaOnTrace(object sender, TraceEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new TraceEventHandler(MediaOnTrace), sender, e);
}
else
{
TraceView.AppendText(e.ToString() + Environment.NewLine);
}
}
private void duktape_Print(object sender, TraceEventArgs e)
{
PluginManager.Core.Invoke(new Action(() =>
{
if (e.Text.StartsWith("trace: ") && !plugin.Conf.ShowTraceInfo)
{
return;
}
Panes.Console.Print(e.Text);
}), null);
}
/// <summary>
/// Callback for logging OPC UA stack trace output
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">The trace event args.</param>
public void TraceEventHandler(object sender, TraceEventArgs e)
{
if ((e.TraceMask & m_traceMasks) != 0)
{
if (e.Exception != null)
{
m_writer.WriteLine(e.Exception);
}
m_writer.WriteLine(string.Format(e.Format, e.Arguments));
}
}
void profiler_TraceEvent(object sender, TraceEventArgs e)
{
foreach (DataRow row in e.EventsTable.Rows)
{
string result = "";
foreach (object o in row.ItemArray)
{
result += " " + o.ToString();
}
Console.WriteLine(result);
}
}
/// <summary>
/// Callback for logging OPC UA stack trace output.
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">The trace event args.</param>
public void TraceEventHandler(object sender, TraceEventArgs e)
{
LastTraceEventArgs = e;
if (e.Exception != null)
{
m_writer.WriteLine(e.Exception);
m_traceList.Add(e.Exception.Message);
}
string message = string.Format(e.Format, e.Arguments);
m_writer.WriteLine(message);
m_traceList.Add(message);
}
private void TraceItemAdded(object sender, TraceEventArgs e)
{
lstTrace.Invoke(new TraceChanged(AddToTrace), e.ExecutedAction.ToString());
if (e.ExecutedAction.IsDeadlocked)
{
if (_visual != null && _chosenAction != null)
{
UpdateState();
}
lstCandidateActions.Invoke(new MethodInvoker(lstCandidateActions.Items.Clear));
txtCandidateDescription.Invoke(new MethodInvoker(delegate() { txtCandidateDescription.Text = ""; }));
}
}
/// <summary>
/// Event handler to log OPC UA stack trace messages into own logger.
/// </summary>
///
///
///
private static void LoggerOpcUaTraceHandler(object sender, TraceEventArgs e)
{
// return fast if no trace needed
if ((e.TraceMask & OpcStackTraceMask) == 0)
{
return;
}
// e.Exception and e.Message are always null
// format the trace message
string message = string.Empty;
message = string.Format(e.Format, e.Arguments)?.Trim();
message = "OPC: " + message;
// map logging level
if ((e.TraceMask & OpcTraceToLoggerVerbose) != 0)
{
Logger.Verbose(message);
return;
}
if ((e.TraceMask & OpcTraceToLoggerDebug) != 0)
{
Logger.Debug(message);
return;
}
if ((e.TraceMask & OpcTraceToLoggerInformation) != 0)
{
Logger.Information(message);
return;
}
if ((e.TraceMask & OpcTraceToLoggerWarning) != 0)
{
Logger.Warning(message);
return;
}
if ((e.TraceMask & OpcTraceToLoggerError) != 0)
{
Logger.Error(message);
return;
}
if ((e.TraceMask & OpcTraceToLoggerFatal) != 0)
{
Logger.Fatal(message);
return;
}
return;
}
private void Trace_DebugMessageSent(object sender, TraceEventArgs e)
{
try
{
Console.WriteLine(string.Format("{0} Debug", e.ClassName));
//Console.WriteLine(e);
using (var activity = MyActivitySource.StartActivity("SayHello"))
{
activity.SetTag("e", e);
}
}
catch (Exception ex)
{
}
}
void queryTrc_OnEvent(object sender, TraceEventArgs e)
{
sw.WriteLine("/*");
sw.WriteLine("Database : " + e.DatabaseName);
sw.WriteLine("User Name : " + e.NTCanonicalUserName);
//sw.WriteLine("Parameters : " + e.RequestParameters);
//sw.WriteLine("Properties : " + e.RequestProperties);
sw.WriteLine("Start Time : " + e.StartTime.ToString("dd MMM yyyy hh:mm:ss"));
sw.WriteLine("*/");
sw.WriteLine("");
sw.WriteLine(ReplaceQueryParameters(e.TextData, e.RequestParameters) + ";");
sw.WriteLine("GO");
sw.WriteLine("");
QueryCaptured();
}
/// <summary>
/// Vygeneruje event oznamujuci poziadavku na logovanie informacii
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">TraceEventArgs</param>
protected virtual void OnTrace(Object sender, TraceEventArgs e)
{
TraceEventHandler handler = this.traceEvent;
if (handler != null)
{
if (this._traceEventAsync)
{
handler.BeginInvoke(sender, e, null, null);
}
else
{
handler(sender, e);
}
}
}
private void OnInstanceShowMessage(object sender, TraceEventArgs e)
{
if (this.Dispatcher == Dispatcher.CurrentDispatcher)
{
logBox.Text = RedirectorTraceListener.Current.Log;
logBox.ScrollToEnd();
}
else
{
Dispatcher.Invoke((Action) delegate
{
logBox.Text = RedirectorTraceListener.Current.Log;
logBox.ScrollToEnd();
});
}
}
void _listener_Message(object sender, TraceEventArgs e)
{
if (this.InvokeRequired)
{
this.Invoke(new listenerMessageDelegate(_listener_Message), sender, e);
}
else
{
ListViewItem item = new ListViewItem();
item.ImageIndex = (e.Level == TraceLevel.Error) ? 3 : (e.Level == TraceLevel.Warning) ? 2 : (e.Level == TraceLevel.Info) ? 1 : 0;
item.Text = DateTime.Now.ToString();
item.SubItems.Add(e.Message);
listView1.Items.Add(item);
listView1.EnsureVisible(listView1.Items.Count - 1);
}
}
void Instance_Trace(TraceEventArgs e)
{
if (txtTrace.InvokeRequired)
{
Invoke(new MethodInvoker(() =>
{
txtTrace.AppendText(e.Message);
txtTrace.AppendText(System.Environment.NewLine);
}));
}
else
{
txtTrace.AppendText(e.Message);
txtTrace.AppendText(System.Environment.NewLine);
}
Application.DoEvents();
}
private void Trace_InformationMessageSent(object sender, TraceEventArgs e)
{
try
{
Console.WriteLine(string.Format("{0} Information", e.ClassName), Color.Green);
//Console.WriteLine(e, Color.Green);
using (var activity = MyActivitySource.StartActivity("SayHello"))
{
activity.SetTag("e", e);
}
if (e.MethodName == "#### DlcManager #####: DlcCreated")
{
Console.WriteLine(e, Color.Gold);
}
}catch (Exception ex) { }
}
void trc_OnEvent(object sender, TraceEventArgs e)
{
try
{
MyTraceEventArgs args = new MyTraceEventArgs(e);
HandleTraceEvent(args);
}
catch (Exception ex)
{
try
{
bStopped = true;
FinishExecute(false);
}
catch { }
MessageBox.Show("There was a problem receiving a trace event: " + ex.Message);
}
}
public void Trace_OnEvent(object sender, TraceEventArgs e)
{
if (e.EventClass == TraceEventClass.QueryEnd)
{
this.QueryExecutionTimes[this.QueryExecutionTimes.Count - 1].Add(e.Duration);
if (this.QueryExecutionTimes[this.QueryExecutionTimes.Count - 1].Count == this.RepetitionsToDoList[CurrentQueryIndex])
{
if (this.CurrentQueryIndex != this.RepetitionsToDoList.Count - 1)
{
this.QueryExecutionTimes.Add(new List <long>());
this.CurrentQueryIndex++;
return;
}
this.CurrentQueryIndex = 0;
this.ReadyToDisplayChart(this, null);
}
}
}
static void Program_Message(object sender, TraceEventArgs e)
{
string text;
if (e.Level >= TraceLevel.Info)
{
text = e.Message;
}
else
{
text = e.Level.ToString().ToUpper() + " : " + e.Message;
}
Console.WriteLine(text);
if (_logFileWriter != null && _logFileWriter.BaseStream.CanWrite)
{
_logFileWriter.WriteLine(text);
}
}
/// <summary>
/// Event handler method for logging compilation errors and warnings, <c>fn:trace</c> and <c>xsl:message</c>
/// </summary>
/// <param name = "sender">The sender.</param>
/// <param name = "e">The <see cref = "XmlPrime.TraceEventArgs" /> instance containing the event data.</param>
protected void OnTrace(object sender, [NotNull] TraceEventArgs e)
{
Assert.ArgumentNotNull(e, "e");
var source = e.SourceUri == null
? null
: new Uri(e.SourceUri);
var msg = string.Format("{0}: {1}, {2}: {3}: {4}",
source == null
? null
: source.Scheme == Uri.UriSchemeFile
? source.LocalPath
: source.ToString(),
e.LineNumber,
e.LinePosition,
e.Label,
e.Value);
Log.LogMessage(MessageImportance.Normal, msg);
}
void trc_OnEvent(object sender, TraceEventArgs e)
{
try
{
lock (this) //will this help ensure we run the code in serial, not in parallel?? it's important for this code to load the trace events in serial and in order
{
MyTraceEventArgs args = new MyTraceEventArgs(e);
HandleTraceEvent(args);
}
}
catch (Exception ex)
{
try
{
bStopped = true;
FinishExecute(false);
}
catch { }
MessageBox.Show("There was a problem receiving a trace event: " + ex.Message);
}
}
void trc_OnEvent(object sender, TraceEventArgs e)
{
try
{
MyTraceEventArgs args = new MyTraceEventArgs(e);
HandleTraceEvent(args);
}
catch (Exception ex)
{
try
{
bStopped = true;
FinishExecute(false);
}
catch { }
MessageBox.Show("There was a problem receiving a trace event: " + ex.Message);
}
}
/// <summary>
/// Handle the "Done" event.
/// </summary>
/// <param name="source">Event source object</param>
/// <param name="e">Event data object</param>
public virtual void doneParsing(object source, TraceEventArgs e)
{
}
private void ProgressReportHandler(object sender, TraceEventArgs e)
{
Console.WriteLine(e[TraceColumn.TextData]);
}
void trc_OnEvent(object sender, TraceEventArgs e)
{
try
{
lock (this) //will this help ensure we run the code in serial, not in parallel?? it's important for this code to load the trace events in serial and in order
{
MyTraceEventArgs args = new MyTraceEventArgs(e);
HandleTraceEvent(args);
}
}
catch (Exception ex)
{
try
{
bStopped = true;
FinishExecute(false);
}
catch { }
MessageBox.Show("There was a problem receiving a trace event: " + ex.Message);
}
}
private void OnTraceEventInternal(object sender, TraceEventArgs e)
{
// we are using CommandBegin as a "heartbeat" to check if the trace
// has started capturing events
if (!_traceStarted)
{
StopTimer();
_traceStarted = true;
Status = QueryTraceStatus.Started;
if (TraceStarted != null)
TraceStarted(this, null);
}
else
{
System.Diagnostics.Debug.Print("TraceEvent: {0}", e.EventClass.ToString());
OnTraceEvent(e);
_capturedEvents.Add(new DaxStudioTraceEventArgs(e));
if (e.EventClass == TraceEventClass.QueryEnd)
{
// Raise an event with the captured events
if (TraceCompleted != null)
TraceCompleted(this, _capturedEvents);
// reset the captured events collection
_capturedEvents = new List<DaxStudioTraceEventArgs>();
}
}
}
/// <summary>
/// Handle the "ExitRule" event
/// </summary>
/// <param name="source">Event source object</param>
/// <param name="e">Event data object</param>
public virtual void exitRule(object source, TraceEventArgs e)
{
}
public MyTraceEventArgs(TraceEventArgs args)
{
EventClass = args.EventClass;
EventSubclass = args.EventSubclass;
DatabaseName = args.DatabaseName;
ObjectPath = args.ObjectPath;
TextData = args.TextData;
}
private void listener_TextWritten(object sender, TraceEventArgs args) {
string indent = "";
for (int x = 0; x < Trace.IndentLevel; x++) {
indent += "\t";
}
try {
if (txtOutput.Text.Length > 23000)
txtOutput.Text = "...(OUTPUT TRUNCATED)..." + txtOutput.Text.Substring(txtOutput.Text.Length - 15000);
}
catch {}
txtOutput.AppendText(indent + args.TraceText);
//statusBar.Text = args.TraceText.Trim();//txtOutput.Text.Length.ToString();
Application.DoEvents();
}
public MyTraceEventArgs(TraceEventArgs args)
{
EventClass = args.EventClass;
DatabaseName = args.DatabaseName;
ObjectPath = args.ObjectPath;
TextData = args.TextData;
SessionIdOrSpid = args.SessionID;
}
public override void exitRule(object source, TraceEventArgs e)
{
dedent();
System.Console.Out.WriteLine(indentString + e);
}
void DebugTraceListener_TraceMessage(object sender, TraceEventArgs e)
{
WriteLine(e.Message);
}
private void trace_OnEvent(object sender, TraceEventArgs e)
{
try
{
if (e.EventClass == TraceEventClass.GetDataFromAggregation)
{
if (!e.ObjectPath.StartsWith(_currentMGPath)) return;
if (e.SessionID != _sessionID && e.ConnectionID != "0") return; //has to either be this session or the admin session (under which ExecuteMdxScript runs)
string sPartitionID = e.ObjectPath.Substring(_currentMGPath.Length);
Partition partition = _currentAggD.Parent.Partitions.Find(sPartitionID);
if (partition == null) return;
string sAggID = e.TextData.Split(new char[] { '\r', '\n' })[0];
if (partition.AggregationDesign == null) return;
Aggregation agg = partition.AggregationDesign.Aggregations.Find(sAggID);
if (agg == null) return;
lock (_dictHitAggs)
{
if (_dictHitAggs.ContainsKey(agg))
{
_dictHitAggs[agg]++;
}
else
{
_dictHitAggs.Add(agg, 1);
}
}
}
else if (e.EventClass == TraceEventClass.QueryEnd)
{
if (e.SessionID != _sessionID) return;
_queryEnded = true;
_queryDuration = e.Duration;
}
}
catch { } //ignore errors
}
public void OnTraceEvent( TraceEventArgs e)
{
if (TraceEvent != null)
TraceEvent(this, e);
}
private void OnTraceEventInternal(object sender, TraceEventArgs e)
{
// we are using CommandBegin as a "heartbeat" to check if the trace
// has started capturing events
if (!_traceStarted)
{
StopTimer();
_traceStarted = true;
Status = QueryTraceStatus.Started;
if (TraceStarted != null)
TraceStarted(this, new TraceStartedEventArgs());
}
else
{
OnTraceEvent(e);
if (e.EventClass == TraceEventClass.QueryEnd)
{
//Stop();
if (TraceCompleted != null)
TraceCompleted(this, null);
}
}
}
void imlInterp_TraceMessage(object sender, TraceEventArgs e)
{
LoggingService.AddLogEntry(LogLevel.Basic, "(Line " + lineNumber + ") " + e.Message, e.IsError);
}
public void TestCreate()
{
var target = new TraceEventArgs("message");
Assert.AreEqual("message", target.Message);
}
