public void Performance_Tracing_To_File()
{
TracerConfig.Reset(@"file c:\temp\trace_uTest.txt; * *");
Action acc = GenerateTraces;
acc.Profile(50 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void FullDataRun(Application app, FileUtils util, PerformanceUtils utilPerf, QueryUtils utilQuery, Server server)
{
util.Cleanup("results");
util.ReadCrimes(app);
var crimeSourceFull = util.GetFullStream(app);
utilQuery.DataQuery(crimeSourceFull, out var severityAverageFull);
var tracerConfig = new TracerConfig()
{
DisplayCtiEvents = false,
SingleLine = true,
TraceName = "",
TracerKind = TracerKind.FileFull
};
var outputStream = app.DefineStreamableSink <double>(typeof(TracerFactory),
tracerConfig,
EventShape.Point,
StreamEventOrder.FullyOrdered);
using (severityAverageFull.Bind(outputStream).Run("process"))
{
utilPerf.MonitorPerformance(server, "performance/performanceFull.txt");
System.Threading.Thread.Sleep(200);
}
}
public void Performance_Static_Traces_To_Null_Device()
{
TracerConfig.Reset("null; * *");
Action acc = GenerateStaticTraces;
acc.Profile(500 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Performance_Tracing_To_DebugOutput()
{
TracerConfig.Reset(@"DebugOutput; * *");
Action acc = GenerateTraces;
acc.Profile(50 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Performance_Tracing_To_Null_Device_Not_Matching()
{
TracerConfig.Reset("null; xxx *");
Action acc = GenerateTraces;
acc.Profile(500 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Trace_Only_Exceptions()
{
TracerConfig.Reset("null;* Exception");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
const int Runs = 20;
for (int i = 0; i < Runs; i++)
{
string exStr = "Ex Nr" + i;
try
{
using (Tracer tr1 = new Tracer(myType, "Enclosing Method"))
{
using (Tracer tracer = new Tracer(myType, "Thread Method"))
{
throw new NotImplementedException(exStr);
}
}
}
catch (Exception)
{ }
Assert.AreEqual(i + 1, stringTracer.Messages.Count);
Assert.IsTrue(stringTracer.Messages[i].Contains(exStr),
String.Format("Got {0} but did not find substring {1}", stringTracer.Messages[i], exStr));
}
}
public void Trace_From_ManyThreads()
{
TracerConfig.Reset("null;* *");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
List <Thread> threads = new List <Thread>();
int Threads = 5;
int GenerateCount = 10 * 1000;
int LinesPerGenerate = 5;
for (int i = 0; i < Threads; i++)
{
Thread t = new Thread(new ParameterizedThreadStart(GenerateTraces));
t.IsBackground = true;
t.Start(GenerateCount);
threads.Add(t);
}
threads.ForEach((t) => t.Join());
Assert.AreEqual(Threads * GenerateCount * LinesPerGenerate, stringTracer.Messages.Count);
HashSet <int> threadIds = new HashSet <int>();
foreach (var line in stringTracer.Messages)
{
threadIds.Add(int.Parse(line.Substring(20, 4)));
}
Assert.AreEqual(Threads, threadIds.Count);
}
public void PartDataRun(Application app, FileUtils util, PerformanceUtils utilPerf, QueryUtils utilQuery,
Server server, int noOfTries, int howMany, int seqLength)
{
while (noOfTries != 0)
{
util.TruncateCrimes(app, howMany, seqLength);
var crimeSourcePart = util.GetPartStream(app);
utilQuery.DataQuery(crimeSourcePart, out var severityAveragePart);
var tracerConfig2 = new TracerConfig()
{
DisplayCtiEvents = false,
SingleLine = true,
TraceName = "",
TracerKind = TracerKind.FilePartial
};
var outputStream2 = app.DefineStreamableSink <double>(typeof(TracerFactory),
tracerConfig2,
EventShape.Point,
StreamEventOrder.FullyOrdered);
using (severityAveragePart.Bind(outputStream2).Run("process"))
{
utilPerf.MonitorPerformance(server, "performance2/performancePart" + new Random().Next(100) + ".txt");
System.Threading.Thread.Sleep(200);
}
noOfTries--;
}
}
public void Performance_Tracing_Is_Off()
{
TracerConfig.Reset(null);
Action acc = GenerateTraces;
acc.Profile(5 * 1000 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Can_Trace_Info()
{
TracerConfig.Reset("null;* *");
Tracer t = new Tracer();
t.Info("Hello world {0}", "test");
t.Warning("");
t.Error("");
t.Dispose();
}
public void Trace_Static_Messages_To_DebugOutput()
{
TracerConfig.Reset("debugoutput");
const string MethodName = "Trace_Static_Messages_To_DebugOutput";
Tracer.Info(Level.L1, myType, MethodName, "Info {0}", "world");
Tracer.Warning(Level.L2, myType, MethodName, "Warning {0}", "world");
Tracer.Error(Level.L3, myType, MethodName, "Error {0}", "world");
Tracer.Error(Level.L4, myType, MethodName, new Exception("Test Exception"));
Tracer.Error(Level.L5, myType, MethodName, new Exception("Other Test Exception"), "Error {0}", "world");
}
public void Trace_Instance_Messages_To_DebugOutput()
{
TracerConfig.Reset("debugoutput");
using (Tracer t = new Tracer(myType, "Test_Method"))
{
t.Info("Info message");
t.Warning("Warning message");
t.Error("Error message");
}
}
public void Leave_Method_WithException()
{
TracerConfig.Reset("debugoutput");
try
{
using (Tracer t = new Tracer(myType, "Leave_Method_WithException"))
{
throw new InvalidCastException("test ex");
}
}
catch (Exception)
{
}
}
public void Inject_Fault_After_File_Open()
{
DoSomeLogic();
TracerConfig.Reset("null");
Tracer.TraceEvent += (severity, typemethod, time, message) =>
{
if (severity == Tracer.MsgType.Instrument)
{
throw new IOException("Hi this is an injected fault");
}
};
Assert.Throws <IOException>(() => DoSomeLogic());
}
public void Performance_Of_Action_Delegate()
{
int called = 0;
TracerConfig.Reset("null;* Level1");
Action prof = () =>
{
Tracer.Execute(MessageTypes.Info, Level.L1, myType, () => called++);
};
const int Runs = 1000 * 1000;
prof.Profile(Runs, "Could execute {0} trace callbacks with {frequency} calls/s in {time}s");
Assert.AreEqual(Runs, called);
Console.WriteLine("Executed {0}", called);
}
public void Every_Thread_Prints_His_Exception_Only_Once()
{
TracerConfig.Reset("null");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
ThreadStart method = () =>
{
try
{
using (Tracer tr1 = new Tracer(myType, "Enclosing Method"))
{
using (Tracer tracer = new Tracer(myType, "Thread Method"))
{
throw new NotImplementedException(Thread.CurrentThread.Name);
}
}
}
catch (Exception)
{ }
};
List <Thread> threads = new List <Thread>();
const int ThreadCount = 3;
List <string> threadNames = new List <string>();
for (int i = 0; i < ThreadCount; i++)
{
Thread t = new Thread(method);
string threadName = "Tracer Thread " + i;
t.Name = threadName;
threadNames.Add(threadName);
t.Start();
threads.Add(t);
}
threads.ForEach(t => t.Join());
var exLines = stringTracer.GetMessages(line => line.Contains("Exception"));
Assert.AreEqual(ThreadCount, exLines.Count);
for (int i = 0; i < threadNames.Count; i++)
{
Assert.IsTrue(exLines.Any(traceLine => traceLine.Contains(threadNames[i])),
String.Format("Thread with name {0} not found in output", exLines[i]));
}
Assert.AreEqual(ThreadCount * 5, stringTracer.Messages.Count);
}
public void When_Level1_And_Error_IsEnabled_NothingElse_Must_Pass()
{
TracerConfig.Reset("null;* l1+error");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
GenerateLevelTraces(Level.L1);
try
{
Assert.AreEqual(4, stringTracer.Messages.Count);
}
finally
{
ExceptionHelper.WhenException(() => stringTracer.Messages.ForEach((str) => Console.Write(str)));
}
}
public void Can_Inject_Faults()
{
TracerConfig.Reset("null");
GenerateLevelTraces(Level.All);
Tracer.TraceEvent += (msgType, typemethod, time, msg) =>
{
if (msgType == Tracer.MsgType.Error)
{
throw new InvalidOperationException("Injectect Fault");
}
};
Assert.Throws <InvalidOperationException>(() => GenerateLevelTraces(Level.All));
TracerConfig.Reset(null);
GenerateLevelTraces(Level.All);
}
public void Events_Can_Survive_TraceConfig_Reset()
{
TracerConfig.Reset("null");
Tracer.TraceEvent += (msgType, typemethod, time, msg) =>
{
if (msg == "Error trace")
{
throw new InvalidOperationException("Injectect Fault");
}
};
Assert.Throws <InvalidOperationException>(() => GenerateLevelTraces(Level.All));
TracerConfig.Reset("null", false);
Assert.Throws <InvalidOperationException>(() => GenerateLevelTraces(Level.All));
TracerConfig.Reset("null", true);
GenerateLevelTraces(Level.All);
}
public void When_Level2_IsEnabled_NoOtherTracesArrive()
{
TracerConfig.Reset("null;* level2");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
GenerateLevelTraces(Level.L1);
try
{
Assert.AreEqual(0, stringTracer.Messages.Count);
}
finally
{
ExceptionHelper.WhenException(() => stringTracer.Messages.ForEach((str) => Console.Write(str)));
}
}
/// <summary>
/// Appends a secondary query to the specified query and starts it.
/// </summary>
/// <param name="primaryQuery">Primary query to append to.</param>
/// <returns>The secondary query.</returns>
private static Query ComposeSecondaryQuery(Query primaryQuery)
{
// Create a stream based on the output of the primary query.
var inputstream = primaryQuery.ToStream <AnnotatedValue>();
// Specify the secondary query logic: Select only a specific sensor.
var filtered = from e in inputstream
where e.DeviceID == "0"
select e;
// Find the maximum of all sensor values within 5 second windows -
// provided the window contains one or more events.
var result = from win in filtered.TumblingWindow(TimeSpan.FromSeconds(5), HoppingWindowOutputPolicy.ClipToWindowEnd)
select new { Max = win.Max(e => e.ValueDelta) };
// Display the result of this query in the console window, but with
// a different tracer name.
var tracerConfig = new TracerConfig()
{
DisplayCtiEvents = false,
SingleLine = true,
TraceName = "MaxDeltas",
TracerKind = TracerKind.Console
};
// Turn this into a query and start it.
// This call does not need an application object, because it is
// already determined by the primary query.
//
// The secondary query will start feeding from the result
// of the primary query, after the primary query has already
// been started and producing events. The secondary query will
// receive the last CTI emitted by the primary query, plus at least
// those events produced by the primary query that overlapped with
// this CTI.
var query = result.ToQuery("OneSensorMaxDelta", string.Empty, typeof(TracerFactory), tracerConfig, EventShape.Interval, StreamEventOrder.FullyOrdered);
query.Start();
return(query);
}
public void Inject_Fault_During_Stream_Read()
{
TracerConfig.Reset("null");
DoSomeLogic();
int lineCount = 0;
Tracer.TraceEvent += (severity, typemethod, time, message) =>
{
if (severity == Tracer.MsgType.Information && message.Contains("Got line from"))
{
lineCount++;
if (lineCount == 2)
{
throw new IOException("Exception during read of second line");
}
}
};
Assert.Throws <IOException>(() => DoSomeLogic());
}
public CommandData Parse(string[] args)
{
CommandData cmdArgs = new CommandData();
myArgs = args;
for (myParseIdx = 0; myParseIdx < args.Length; myParseIdx++)
{
string curArg = MakeArgLowerCase(args[myParseIdx]);
List <string> hookCmd = null;
curArg = TranslateShortToLong(curArg);
switch (curArg)
{
case "corflags":
cmdArgs.Command = Commands.CorFlags;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd);
break;
case "cwd":
var rootDir = NextOptionForArgument();
if (rootDir.Count == 0)
{
cmdArgs.InvalidComandLineSwitch = "cwd";
break;
}
cmdArgs.Cwd = rootDir[0];
break;
case "diff":
cmdArgs.Command = Commands.Diff;
DoNotExpectAdditionalParameters(cmdArgs);
break;
case "in":
AddQuery(cmdArgs.Queries2, cmdArgs);
break;
case "old":
AddQuery(cmdArgs.Queries1, cmdArgs);
break;
case "old2":
AddQuery(cmdArgs.OldFiles2, cmdArgs);
break;
case "searchin":
AddQuery(cmdArgs.SearchInQuery, cmdArgs);
break;
case "new":
AddQuery(cmdArgs.Queries2, cmdArgs);
break;
case "imbalance":
cmdArgs.EventSubscriptionImbalance = true;
break;
case "trace":
TracerConfig.Reset("console;* Level1");
break;
case WhoUsesMethodCommand.Argument:
cmdArgs.Command = Commands.MethodUsage;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
string potentialQuery = hookCmd[0];
if (potentialQuery.Contains("("))
{
cmdArgs.TypeAndInnerQuery = potentialQuery;
}
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoUsesTypeCommand.Argument:
cmdArgs.Command = Commands.WhoUsesType;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.TypeQuery = hookCmd[0];
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoUsesFieldCommand.Argument:
cmdArgs.Command = Commands.WhoUsesField;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.TypeAndInnerQuery = hookCmd[0];
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoUsesEventCommand.Argument:
cmdArgs.Command = Commands.WhoUsesEvent;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.TypeAndInnerQuery = hookCmd[0];
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoImplementsInterfaceCommand.Argument:
cmdArgs.Command = Commands.WhoImplementsInterface;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.TypeQuery = hookCmd[0];
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoUsesStringConstantCommand.Argument:
cmdArgs.Command = Commands.WhoUsesStringConstant;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.StringConstant = hookCmd[0];
if (hookCmd.Count > 1)
{
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
}
break;
case "word":
cmdArgs.WordMatch = true;
break;
case "case":
cmdArgs.CaseSensitiveMatch = true;
break;
case GetFileInfoCommand.Argument:
cmdArgs.Command = Commands.GetFileInfo;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd);
break;
case "whoreferences":
cmdArgs.Command = Commands.WhoReferences;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd);
break;
case "getpdbs":
cmdArgs.Command = Commands.DownloadPdbs;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
AddQuery(cmdArgs.Queries1, cmdArgs, new List <string> {
hookCmd[0]
});
if (hookCmd.Count > 1)
{
cmdArgs.PdbDownloadDir = hookCmd[1];
}
if (hookCmd.Count > 2)
{
cmdArgs.InvalidComandLineSwitch = String.Format("The argument {0} is not valid for this command", hookCmd[2]);
}
break;
case "showrebuildtargets":
cmdArgs.Command = Commands.ShowRebuildTargets;
DoNotExpectAdditionalParameters(cmdArgs);
break;
case "showstrongname":
cmdArgs.Command = Commands.ShowStrongName;
AddQuery(cmdArgs.Queries1, cmdArgs);
break;
case "showreferences":
cmdArgs.Command = Commands.ShowReferences;
AddQuery(cmdArgs.Queries1, cmdArgs);
break;
case "verbose":
cmdArgs.Verbose = true;
break;
case "excel":
cmdArgs.OutputToExcel = true;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.ExcelOutputFileName = hookCmd[0];
break;
case "threads":
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
int newThreadCount = 0;
if (int.TryParse(hookCmd[0], out newThreadCount) && newThreadCount > 0)
{
cmdArgs.ThreadCount = newThreadCount;
}
else
{
cmdArgs.InvalidComandLineSwitch = hookCmd[0];
}
break;
case "fileinfo":
cmdArgs.WithFileInfo = true;
break;
default:
cmdArgs.UnknownCommandLineSwitch = curArg;
break;
}
}
return(cmdArgs);
}
public void AA_Enable_File()
{
TracerConfig.Reset("file");
}
public void AAZ_Disable()
{
TracerConfig.Reset(null);
}
public void Dispose()
{
TracerConfig.Reset(myOldTraceCfg);
}
public void Demo_Show_Leaving_Trace_With_Exception()
{
TracerConfig.Reset("console");
SomeMethod();
}
/// <summary>
/// Main routine.
/// </summary>
internal static void Main()
{
// Creating an embedded server.
//
// NOTE: replace "Default" with the instance name you provided
// during StreamInsight setup.
using (Server server = Server.Create("Default"))
{
// Comment out if you want to create a service host and expose
// the server's endpoint:
//ServiceHost host = new ServiceHost(server.CreateManagementService());
//host.AddServiceEndpoint(
// typeof(IManagementService),
// new WSHttpBinding(SecurityMode.Message),
// "http://localhost/MyStreamInsightServer");
// To enable remote connection / debugging, you also need to uncomment the
// lines "host.Open()" and "host.Close()".
// In addition, the URI needs to be provisioned for the
// account that runs this process (unless Administrator). To do this, open
// an admin shell and execute the following command, using the respective
// user credentials:
// netsh http add urlacl url=http://+:80/MyStreamInsightServer user=<domain\username>
//host.Open();
// Configuration of the data generator input adapter.
var generatorConfig = new GeneratorConfig()
{
CtiFrequency = 1,
EventInterval = 500,
EventIntervalVariance = 450,
DeviceCount = 5,
MaxValue = 100
};
// Configuration of the tracer output adapter.
var tracerConfig = new TracerConfig()
{
DisplayCtiEvents = false,
SingleLine = true,
TraceName = "Deltas",
TracerKind = TracerKind.Console
};
try
{
var myApp = server.CreateApplication("DeviceReadings");
// Create an input stream directly from the adapter,
// requesting point events from the simulator.
var inputstream = CepStream <GeneratedEvent> .Create("input", typeof(GeneratorFactory), generatorConfig, EventShape.Point);
// Compute the delta of consecutive values, using a count window
// and a user-defined aggregate.
// Use group & apply to compute this for each device separately.
var deltas = from e in inputstream
group e by e.DeviceId into eachGroup
from win in eachGroup.CountByStartTimeWindow(2, CountWindowOutputPolicy.PointAlignToWindowEnd)
select new { ValueDelta = win.Delta(e => e.Value), SourceID = eachGroup.Key };
// Annotate the original values with the delta events by joining them.
// The aggregate over the count window produces a point event at
// the end of the window, which coincides with the second event in
// the window, so that they can be joined.
var annotatedValues = from left in inputstream
join right in deltas
on left.DeviceId equals right.SourceID
select new { DeviceID = left.DeviceId, left.Value, right.ValueDelta };
// Turn this logic into a query, outputting to the tracer output adapter.
var primaryQuery = annotatedValues.ToQuery(
myApp,
"Deltas",
string.Empty,
typeof(TracerFactory),
tracerConfig,
EventShape.Point,
StreamEventOrder.FullyOrdered);
// Start the query now.
primaryQuery.Start();
// Append and start another query through Dynamic Query Composition,
// passing the primary query object.
var secondaryQuery = ComposeSecondaryQuery(primaryQuery);
// Wait for keystroke to end.
Console.ReadLine();
// Stop both queries.
primaryQuery.Stop();
secondaryQuery.Stop();
Console.WriteLine("Query stopped. Press enter to exit application.");
Console.ReadLine();
//host.Close();
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadLine();
}
}
}
/// <summary>
/// Main routine.
/// </summary>
internal static void Main()
{
// Creating an embedded server.
//
// NOTE: replace "Default" with the instance name you provided
// during StreamInsight setup.
using (Server server = Server.Create("Default"))
{
// Comment out if you want to create a service host and expose
// the server's endpoint:
//ServiceHost host = new ServiceHost(server.CreateManagementService());
//host.AddServiceEndpoint(
// typeof(IManagementService),
// new WSHttpBinding(SecurityMode.Message),
// "http://localhost/MyStreamInsightServer");
// To enable remote connection / debugging, you also need to uncomment the
// lines "host.Open()" and "host.Close()".
// In addition, the URI needs to be provisioned for the
// account that runs this process (unless Administrator). To do this, open
// an admin shell and execute the following command, using the respective
// user credentials:
// netsh http add urlacl url=http://+:80/MyStreamInsightServer user=<domain\username>
//host.Open();
try
{
Application myApp = server.CreateApplication("DeviceReadings");
// Configuration of the data generator input adapter.
var generatorConfig = new GeneratorConfig()
{
CtiFrequency = 1,
EventInterval = 500,
EventIntervalVariance = 450,
DeviceCount = 5,
MaxValue = 100
};
// Define a source stream based on an adapter implementation, which requests point events from the simulator
var inputStream = myApp.DefineStreamable <GeneratedEvent>(typeof(GeneratorFactory), generatorConfig, EventShape.Point, null);
// Configuration of the tracer output adapter 1.
var tracerConfig1 = new TracerConfig()
{
DisplayCtiEvents = false,
SingleLine = true,
TraceName = "Deltas",
TracerKind = TracerKind.Console
};
var outputStream1 = myApp.DefineStreamableSink <AnnotatedValue>(typeof(TracerFactory),
tracerConfig1,
EventShape.Point,
StreamEventOrder.FullyOrdered);
// Configuration of the tracer output adapter 2.
var tracerConfig2 = new TracerConfig()
{
DisplayCtiEvents = false,
SingleLine = true,
TraceName = "MaxDeltas",
TracerKind = TracerKind.Console
};
var outputStream2 = myApp.DefineStreamableSink <float>(typeof(TracerFactory),
tracerConfig2,
EventShape.Interval,
StreamEventOrder.FullyOrdered);
// Annotate the original values with the delta events by joining them.
// The aggregate over the count window produces a point event at
// the end of the window, which coincides with the second event in
// the window, so that they can be joined.
var annotatedValues = inputStream.Multicast(s =>
from left in s
join right in
(from e in s
group e by e.DeviceId into eachGroup
from win in eachGroup.CountWindow(2)
select new { ValueDelta = win.Delta(e => e.Value), SourceID = eachGroup.Key }
)
on left.DeviceId equals right.SourceID
select new AnnotatedValue()
{
DeviceID = left.DeviceId, Value = left.Value, ValueDelta = right.ValueDelta
});
var filtered = from e in annotatedValues
where e.DeviceID == "0"
select e;
var maxDelta = from win in filtered.TumblingWindow(TimeSpan.FromSeconds(5))
select win.Max(e => e.ValueDelta);
// Hydra is used to bind multiple queries
using (annotatedValues.Bind(outputStream1).With(maxDelta.Bind(outputStream2)).Run())
{
// Wait for keystroke to end.
Console.WriteLine("Press enter to stop.");
Console.ReadLine();
}
Console.WriteLine("Process stopped. Press enter to exit application.");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadLine();
}
}
}
public TraceReset(string newTraceCfg)
{
myOldTraceCfg = TracerConfig.Reset(newTraceCfg);
}
