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); } }
/// <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]); }
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) { }
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 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); }