//
// The Run method is the entry point of a background task.
//
public async void Run(IBackgroundTaskInstance taskInstance)
{
_deferral = taskInstance.GetDeferral();
if (lc == null)
{
lc = new LoggingChannel("Tile", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
}
lc.LogMessage("Run entry");
Debug.WriteLine("Background " + taskInstance.Task.Name + " Starting...");
PlaySound();
//
// Associate a cancellation handler with the background task.
//
taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled);
//
// Get the deferral object from the task instance, and take a reference to the taskInstance;
//
//_deferral = taskInstance.GetDeferral();
_taskInstance = taskInstance;
//_periodicTimer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(PeriodicTimerCallback), TimeSpan.FromSeconds(1));
}
private async void Picker_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
var folderPicker = new Windows.Storage.Pickers.FolderPicker();
folderPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
folderPicker.FileTypeFilter.Add("*");
Windows.Storage.StorageFolder folder = await folderPicker.PickSingleFolderAsync();
if (folder != null)
{
log.LogMessage("Folder Picked");
// Application now has read/write access to all contents in the picked folder
// (including other sub-folder contents)
Windows.Storage.AccessCache.StorageApplicationPermissions.
FutureAccessList.AddOrReplace("PickedFolderToken", folder);
//Show the chosen path
this.folderTextBox.Text = folder.Path;
}
else
{
this.folderTextBox.Text = "Operation cancelled.";
}
}
/// <summary>
/// Start of the Webpage. Load all the files required for webpage presentation
/// Bind and listen to socket
/// </summary>
public async void Start()
{
await Task.Run(() => BackupLogFile());
headerFile = File.ReadAllText("webpages\\header.html");
cssFile = File.ReadAllText("webpages\\theme.css");
bodyFile = File.ReadAllText("webpages\\body.html");
StreamSocketListener listener = new StreamSocketListener();
await listener.BindServiceNameAsync(Constants.SOCKET);
listener.ConnectionReceived += Listener_ConnectionReceived;
if (LOG)
{
lc.LogMessage("Webhost started successfully");
}
if (writeLog)
{
WriteDebugInfo("Webhost started successfully");
}
//UDP Listener for Temperature and Intruder sensors
LSS.Initialise();
//Actions for Automation
PA.Initialise();
}
/// <summary>
/// Logs a verbose message.
/// </summary>
/// <param name="message">The message string to log.</param>
public static void Log(string message)
{
#if !NETFX_CORE
Trace.WriteLine(message, VerboseCategory);
#else
_channel.LogMessage(message);
#endif
}
protected override async Task <bool> OnOpeningAsync()
{
try
{
InitializeTokens();
var serialPortsSelector = SerialDevice.GetDeviceSelector();
var devices = await DeviceInformation.FindAllAsync(serialPortsSelector);
if (!devices.Any())
{
throw new Exception(ExceptionMessages.NoDeviceFound);
}
var deviceIds = devices
.Where(device => device.Name.StartsWith(StmDeviceName))
.Select(device => device.Id)
.ToList();
if (deviceIds.Count > 1)
{
throw new Exception(ExceptionMessages.MultipleDevicesFound);
}
var firstDeviceId = deviceIds.FirstOrDefault();
if (firstDeviceId == null)
{
throw new Exception(ExceptionMessages.NoSpecificDeviceFound);
}
_device = await SerialDevice.FromIdAsync(firstDeviceId);
if (_device == null)
{
throw new Exception(ExceptionMessages.CouldNotConnect);
}
_dataReaderObject = new DataReader(_device.InputStream);
_readTask = Task.Run(TryReadAsync, _readCancellationToken);
return(true);
}
catch (Exception ex)
{
// TODO POP TO UI - change how this method is invoked
_loggingChannel.LogMessage($"{ex.Message}", LoggingLevel.Error);
return(false);
}
}
public static void Debug(
object data = null,
string tag = null,
[CallerMemberName] string memberName = null,
[CallerFilePath] string sourceFilePath = null,
[CallerLineNumber] int sourceLineNumber = -1)
{
string message = FormatLogString(data, tag, memberName, sourceFilePath, sourceLineNumber);
System.Diagnostics.Debug.WriteLine(message);
#if WINDOWS_UWP
loggingChannel?.LogMessage(message, LoggingLevel.Verbose); // For ETW logging through UWP Device Portal. Read more at https://blogs.windows.com/buildingapps/2016/06/10/using-device-portal-to-view-debug-logs-for-uwp/#1CvyvpPD4lUTtPzc.99
#endif
}
private async void OnUnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
if (sender != null)
{
logChannel.LogMessage(sender.ToString());
}
e.UnhandledError.Propagate();
}
catch (Exception exception)
{
await Log(exception);
}
}
public static void Log(string message, LoggingLevel level)
{
loggingChannel.LogMessage(message, level);
#if DEBUG
Debug.WriteLine(message);
#endif
}
public static async void LogMessageToFile(string message, LoggingLevel level)
{
// Initialization
if (fileLoggingSession == null)
{
fileLoggingSession = new FileLoggingSession("NewTestamentLogSession");
}
using (var loggingChannel = new LoggingChannel(
"NewTestamentLogSession",
new LoggingChannelOptions(new Guid("2e0582f3-d1b6-516a-00e3-9fd79ef95200")))) // Join a provider group
{
// The Id is generated by hashing the string "SampleProvider".
// channel.Id == eff1e128-4903-5093-096a-bdc29b38456f
fileLoggingSession.AddLoggingChannel(loggingChannel);
// Log messages
loggingChannel.LogMessage(message, level);
}
var file = await fileLoggingSession.CloseAndSaveToFileAsync();
StorageFolder sampleAppDefinedLogFolder =
await ApplicationData.Current.LocalFolder.CreateFolderAsync("Logs", CreationCollisionOption.OpenIfExists);
string newLogFileName = "Log1-" + TimeStamp.Now() + ".etl";
await file.MoveAsync(sampleAppDefinedLogFolder, newLogFileName);
}
/// <summary>
/// Logs to <see cref="Constants.ETWChannelName"/> and either to <see cref="Debug.WriteLine"/> or <see cref="CustomLog"/>
/// </summary>
public static void Log(string message, LoggingLevel level)
{
/*
* You can collect the events generated by this method with xperf or another
* ETL controller tool. To collect these events in an ETL file:
*
* xperf -start MySession -f MyFile.etl -on Constants.ETWGuid
* (call LogError())
* xperf -stop MySession
*
* After collecting the ETL file, you can decode the trace using xperf, wpa,
* or tracerpt. For example, to decode MyFile.etl with tracerpt:
*
* tracerpt MyFile.etl
* (generates dumpfile.xml)
*/
using (var channel = new LoggingChannel(Constants.ETWChannelName, null /*default options*/, new Guid(Constants.ETWGuid)))
{
channel.LogMessage(message, level);
}
if (CustomLog != null)
{
CustomLog(message, level);
}
else
{
Debug.WriteLine("[" + Constants.ETWChannelName + "] [" + level.ToString() + "] " + message);
}
}
/*************************
* OutputWebPages checks whether the data coming in is "Request=Feedback" if it is then
* only the feedback variable is sent back prefixed with "Result: ". Thus the jquery
* in HTML webpage can look for this keyword at the begining of the text to take any
* action.
* If Feedback info is not requested, a webpage is constructed and sent. Note that the
* Header and body tags are added to the webpage while the contents are read from
* respective files. A line for providing the log is added at the end with an ID of retVal for
* calling theme benefit. The log line provides decoded input passed by webpage
* ***********************/
private async void OutputWebPage(StreamSocketListenerConnectionReceivedEventArgs args, string inputString)
{
bAction = inputString.Contains("Action");
//Use the next two lines for event logging
//lc = new LoggingChannel("my provider", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
//lc.LogMessage(inputString.ToString());
string data = string.IsNullOrWhiteSpace(feedBack) ? "None" : feedBack;
try
{
using (IOutputStream output = args.Socket.OutputStream)
{
using (Stream response = output.AsStreamForWrite())
{
if (bAction)
{
//data = "Results: " + feedBack;
//data = DateTime.Now.TimeOfDay.ToString();
byte[] fbArray = Encoding.UTF8.GetBytes(data);
await response.WriteAsync(fbArray, 0, fbArray.Length);
await response.FlushAsync();
//Use the next two lines for event logging
//lc = new LoggingChannel("my provider", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
//lc.LogMessage(feedBack);
}
else
{
byte[] bodyArray = Encoding.UTF8.GetBytes(
$"<!DOCTYPE html>\n<html>\n<head>{headerFile}<style>{cssFile}</style>\n</head>\n<body>{bodyFile}<p>Feedback Received: <span id=\"retVal\">{data}</span></p>\n</body>\n</html>");
var bodyStream = new MemoryStream(bodyArray);
var header = "HTTP/1.1 200 OK\r\n" +
$"Content-Length: {bodyStream.Length}\r\n" +
"Connection: close\r\n\r\n";
byte[] headerArray = Encoding.UTF8.GetBytes(header);
await response.WriteAsync(headerArray, 0, headerArray.Length);
await bodyStream.CopyToAsync(response);
await response.FlushAsync();
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception Occured: {0}", ex);
//Uncomment next two lines for logging the exception errors
lc = new LoggingChannel("my provider", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
lc.LogMessage("Exception at Output Page: " + ex);
bMsg = false;
}
}
public MainPage()
{
InitializeComponent();
LoggingChannel lc = new LoggingChannel("my provider", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
lc.LogMessage("I made a message!");
}
public void Run(IBackgroundTaskInstance taskInstance)
{
using (var loggingChannel = new LoggingChannel("my provider", null, new Guid(loggingChannelId)))
{
loggingChannel.LogMessage("Back ground task started");
if (taskInstance == null)
{
return;
}
taskDeferral = taskInstance.GetDeferral();
LocalDataStore.CreateLocalConfigurationSettings();
// taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled);
var processor = new Processor(loggingChannel);
processor.Process();
Thread.Sleep(28800000);//ToDo-Temporary provision to run this service for a specified period(8 hours)..Should add Scheduler logic.
taskDeferral.Complete();
loggingChannel.LogMessage("Task completed at " + DateTime.UtcNow.ToString());
}
}
/// <summary>
/// IBackgroundTask starting point. Initializes logging
/// </summary>
/// <param name="taskInstance">IBackgroundTaskInstance object</param>
public async Task Run()
{
//Create services
_logging = new LoggingChannel(_loggingAppName, null, _loggingAppId);
_azureIoTHubService = new AzureIoTHubService(_loggingAppId);
_azureIoTHubService.SetDesiredPropertyCallback(ReceiveDesiredConfiguration);
_gpioService = new GPIOService(_loggingAppId);
//First time configuration (runs only once)
_logging.LogMessage("Initializing Application", LoggingLevel.Verbose);
if (!InitApplicationInternal())
{
return;
}
//Run application (loop indefinitely)
_logging.LogMessage("Run Application", LoggingLevel.Verbose);
await RunApplicationInternal();
}
public async Task DeleteOutdatedLogs()
{
try
{
var logFiles = await LoggingFolder.GetFilesAsync();
var obsoleteFiles = logFiles
.Where(logFile => (DateTime.Now - logFile.DateCreated).Days > DaysToDelete);
foreach (var logFile in obsoleteFiles)
{
await logFile.DeleteAsync();
}
}
catch (Exception ex)
{
_loggingChannel.LogMessage(ex.Message, LoggingLevel.Error);
}
}
public void Run(IBackgroundTaskInstance taskInstance)
{
//
// TODO: Insert code to perform background work
//
// If you start any asynchronous methods here, prevent the task
// from closing prematurely by using BackgroundTaskDeferral as
// described in http://aka.ms/backgroundtaskdeferral
//
_deferral = taskInstance.GetDeferral();
// set the security for fms
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
// hook into FMS from settings in the config file
fmserver = GetFMSinstance();
token = string.Empty;
// log into the Events Tracing for Windows ETW
// on the Device Portal, ETW tab, pick "Microsoft-Windows-Diagnostics-LoggingChannel" from the registered providers
// pick level 5 and enable
lc = new LoggingChannel("BillyBassMotorTest", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
lc.LogMessage("Starting up.");
// determine whether we are in testing mode
var resources = new ResourceLoader("Config");
bool testing = Convert.ToBoolean(resources.GetString("testing"));
int polling_interval_testing = Convert.ToInt16(resources.GetString(" polling_interval_testing"));
int polling_interval = Convert.ToInt16(resources.GetString(" polling_interval"));
lc.LogMessage("Testing = " + testing.ToString());
if (testing == false)
{
// start the timer
ThreadPoolTimer timer = ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromMilliseconds(polling_interval));
}
else
{
// start the timer
ThreadPoolTimer timer = ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromSeconds(polling_interval_testing));
}
}
/******************************************
* This procedure listens for messages arriving to socket 8090. This information will be
* built to string. It will then extract the data from the received string
* by calling GetQuery method. The data is properly dispatched to the service connection
* established / stored by this application.
* Finally OutputWebpage is called to provide feedback to the webclient.
* bMsg bool is added to ensure that when multiple messages are received, the messages are discarded.
* This is required. Without this, the Webservice crashes after some time.
******************************************/
private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
if (!bMsg)
{
bMsg = true;
StringBuilder request = new StringBuilder();
try
{
using (IInputStream input = args.Socket.InputStream)
{
byte[] data = new byte[BUFFERSIZE];
IBuffer buffer = data.AsBuffer();
uint dataRead = BUFFERSIZE;
while (dataRead == BUFFERSIZE)
{
await input.ReadAsync(buffer, BUFFERSIZE, InputStreamOptions.Partial);
request.Append(Encoding.UTF8.GetString(data, 0, data.Length));
dataRead = buffer.Length;
}
}
string inputString = GetQuery(request);
//If you are running as a background webserver serviceConnection will be null
//Dispatch the message to the service connection.
if (serviceConnection != null)
{
await serviceConnection.SendMessageAsync(new ValueSet { new KeyValuePair <string, object>("Query", inputString) });
}
OutputWebPage(args, inputString);
}
catch (Exception Ex)
{
Debug.WriteLine("Exception occurred: {0}", Ex);
//Uncomment next two lines for logging the exception errors
lc = new LoggingChannel("my provider", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
lc.LogMessage("Exception at Input String: " + Ex);
bMsg = false;
}
bMsg = false;
}
//Uncomment the else statement if you want to use debugging
/*
* else
* {
* lc = new LoggingChannel("my provider", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
* lc.LogMessage("Multiple messages received");
* }
*/
}
public void Start()
{
if (channel != null)
{
channel.LogMessage(String.Format("Message={0}: Client To Server Application Started!", 1), LoggingLevel.Information);
}
}
public static void LogError(string message)
{
#if !UNITY_EDITOR
portalLogger.LogMessage(message, LoggingLevel.Error);
Debug.LogError(message);
if (logFile == null)
{
logFile = File.CreateText(logPath);
}
logFile.WriteLineAsync("{date:\"" + DateTime.Now.ToString() + "\", message: \"" + message + "\"}");
#endif
}
private void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
_logChannel.LogMessage("Caught and unhandled exception");
e.UnhandledError.Propagate();
}
catch (Exception ex)
{
_logChannel.LogMessage($"Exception Message: {ex.Message}");
}
}
internal async Task Init(int cameraIndex, string cameraResolution)
{
if (IsInitialized)
{
return;
}
_logging.LogMessage("Initializing Camera Service.", LoggingLevel.Verbose);
// Create MediaCapture and its settings
_mediaCapture = new MediaCapture();
// Register for a notification when something goes wrong
_mediaCapture.Failed += MediaCapture_Failed;
var cameraDevice = await GetCameraDeviceByIdAsync(cameraIndex);
if (cameraDevice == null)
{
_logging.LogMessage("No camera device found!", LoggingLevel.Error);
return;
}
// Initialize MediaCapture
try
{
var settings = new MediaCaptureInitializationSettings {
VideoDeviceId = cameraDevice.Id
};
await _mediaCapture.InitializeAsync(settings);
StreamPropertiesModel[] supportedResolutions = GetStreamProperties();
StreamPropertiesModel configuredResolution = supportedResolutions.FirstOrDefault(p => p.Resolution == cameraResolution);
if (configuredResolution == null)
{
configuredResolution = supportedResolutions.FirstOrDefault(p => p.Resolution == "1920x1080");
}
if (configuredResolution == null)
{
configuredResolution = supportedResolutions.FirstOrDefault(p => p.Resolution == "1280x720");
}
if (configuredResolution == null)
{
configuredResolution = supportedResolutions.FirstOrDefault();
}
await _mediaCapture.VideoDeviceController.SetMediaStreamPropertiesAsync(MediaStreamType.Photo, configuredResolution.EncodingProperties);
IsInitialized = true;
}
catch (UnauthorizedAccessException)
{
_logging.LogMessage("CameraService - Init: The app was denied access to the camera", LoggingLevel.Critical);
return;
}
return;
}
internal void Init(string subscriptionKey)
{
_logging.LogMessage("Initializing Cognitive Vision Service.", LoggingLevel.Verbose);
if (string.IsNullOrEmpty(subscriptionKey))
{
_logging.LogMessage("No subscription key for CognitiveVision service found.", LoggingLevel.Error);
}
_subscriptionKey = subscriptionKey;
}
void Start()
{
lc.LogMessage("I made a message!");
// subscribing to the Hololens API gesture recognizer to track user gestures
recognizer = new GestureRecognizer();
recognizer.SetRecognizableGestures(GestureSettings.Tap);
recognizer.Tapped += TapHandler;
recognizer.StartCapturingGestures();
}
public bool InitGPIOInput(int pinIndex, TypedEventHandler <GpioPin, GpioPinValueChangedEventArgs> callback)
{
try
{
GpioPin pin = GetPin(pinIndex);
pin.SetDriveMode(GpioPinDriveMode.Input);
pin.ValueChanged += callback;
return(true);
}
catch (Exception e)
{
_logging.LogMessage($"InitGPIOInput: Error while trying to init gpio '{pinIndex}': {e.Message}", LoggingLevel.Error);
throw e;
}
}
/// <summary>
/// Handle a log message from Untiy Debug
/// </summary>
/// <param name="condition">The message</param>
/// <param name="stackTrace"></param>
/// <param name="type">The type of message (Warning,...)</param>
private void ApplicationOnLogMessageReceived(string condition, string stackTrace, LogType type)
{
LoggingLevel level;
switch (type)
{
case LogType.Error:
level = LoggingLevel.Error;
break;
case LogType.Assert:
level = LoggingLevel.Critical;
break;
case LogType.Warning:
level = LoggingLevel.Warning;
break;
case LogType.Log:
level = LoggingLevel.Information;
break;
case LogType.Exception:
level = LoggingLevel.Critical;
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
loggingChannel.LogMessage(condition, level);
float timeStartup = Time.realtimeSinceStartup;
queue.Enqueue(async() => {
ss.Wait();
await streamWriter.WriteLineAsync($"[{DateTime.Now.ToString("hh:mm:ss", CultureInfo.CurrentCulture)},{string.Format("{0:0.00000}", timeStartup)}] {level.ToString()}: {condition}");
if (!string.IsNullOrEmpty(stackTrace))
{
await streamWriter.WriteLineAsync($"Stacktrace: {stackTrace}");
}
await streamWriter.FlushAsync();
ss.Release();
});
}
private async Task Init(SwapChainPanel swapChainPanel)
{
LoggingChannel = Logger.AddLoggingChannel(Name);
var instance = new Instance(new List <string>
{
"-I",
"dummy",
"--no-osd",
"--verbose=3",
"--no-stats",
"--avcodec-fast",
"--subsdec-encoding",
"",
"--aout=winstore",
$"--keystore-file={Path.Combine(ApplicationData.Current.LocalFolder.Path, KeyStoreFilename)}"
}, swapChainPanel);
Instance = instance;
instance.setDialogHandlers(OnError, OnShowLoginDialog, OnShowDialog,
(dialog, title, text, intermediate, position, cancel) => { },
OnCancelCurrentDialog,
(dialog, position, text) => { });
instance.logSet((param0, param1) =>
{
var logLevel = (LogLevel)param0;
Debug.WriteLine($"[VLC {logLevel}] {param1}");
LoggingChannel.LogMessage(param1, logLevel.ToLoggingLevel());
});
await UpdateScale();
UpdateDeinterlaceMode();
AudioDeviceId = MediaDevice.GetDefaultAudioRenderId(AudioDeviceRole.Default);
MediaDevice.DefaultAudioRenderDeviceChanged += (sender, e) => { if (e.Role == AudioDeviceRole.Default)
{
AudioDeviceId = e.Id;
}
};
OnSourceChanged();
}
int pixelCounter; // zero-based
public async void Run(IBackgroundTaskInstance taskInstance)
{
//
// TODO: Insert code to perform background work
//
// If you start any asynchronous methods here, prevent the task
// from closing prematurely by using BackgroundTaskDeferral as
// described in http://aka.ms/backgroundtaskdeferral
//
_deferral = taskInstance.GetDeferral();
// set the security for fms
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
// hook into FMS from settings in the config file
fmserver = GetFMSinstance();
token = string.Empty;
// hook into the sense hat
senseHat = await SenseHatFactory.GetSenseHat();
// clear the LEDs
senseHat.Display.Clear();
senseHat.Display.Update();
pixelCounter = 0;
// log into the Events Tracing for Windows ETW
// on the Device Portal, ETW tab, pick "Microsoft-Windows-Diagnostics-LoggingChannel" from the registered providers
// pick level 5 and enable
lc = new LoggingChannel("SenseHatFms", null, new Guid("4bd2826e-54a1-4ba9-bf63-92b73ea1ac4a"));
lc.LogMessage("Starting up.");
// start the timer
ThreadPoolTimer timer = ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromSeconds(2));
}
private void LogError()
{
/*
* You can collect the events generated by this method with xperf or another
* ETL controller tool. To collect these events in an ETL file:
*
* xperf -start MySession -f MyFile.etl -on 8aac9209-1e2b-5166-31b6-7c4af4bf7d27
* (call LogError())
* xperf -stop MySession
*
* After collecting the ETL file, you can decode the trace using xperf, wpa,
* or tracerpt. For example, to decode MyFile.etl with tracerpt:
*
* tracerpt MyFile.etl
* (generates dumpfile.xml)
*/
using (var channel = new LoggingChannel("IoTDMBackground", null)) // null means use default options.
{
// Use this Id in xperf parameter
Debug.WriteLine(channel.Id);
channel.LogMessage("Unable to start background app", LoggingLevel.Error);
}
}
/// <summary>
/// This method demonstrates the LoggingChannel and LoggingActivity APIs.
/// </summary>
/// <param name="channel">
/// The channel to use for the demonstration. This channel may have been
/// constructed using a Windows 8.1 constructor or a Windows 10 constructor.
/// The same APIs are supported in both cases, but the ETL events will be
/// formatted a bit differently depending on how the channel was constructed.
/// </param>
private void DemonstrateLogging(LoggingChannel channel)
{
// Whenever any ETW session changes the way it is listening to this
// channel, the LoggingEnable event is fired. For example, this might
// be called when a session begins listening, changes the level at
// which it is listening, or stops listening.
channel.LoggingEnabled += this.OnLoggingEnabled;
// Log simple string events
channel.LogMessage("Simple message"); // default level is Verbose
channel.LogMessage("Simple error", LoggingLevel.Error);
// Log simple string + integer events.
channel.LogValuePair("Simple message", 123); // default level is Verbose
channel.LogValuePair("Simple error", 456, LoggingLevel.Error);
// The channel.Name property returns the name that was used when the
// channel was constructed. When running in Windows 10 mode, the name
// is already set as the provider name, so no LoggingChannelName is
// automatically added to the event.
channel.LogMessage(channel.Name);
// The channel.Id property is new to Windows 10.
channel.LogMessage(channel.Id.ToString());
// If you want to avoid the overhead of collecting data when nobody is
// listening to your channel, check the Enabled property before logging.
if (channel.Enabled)
{
channel.LogMessage(this.CollectExpensiveData());
}
// The IsEnabled() method is exactly the same as the Enabled property,
// except that it is a new Windows 10 API.
if (channel.IsEnabled())
{
channel.LogMessage(this.CollectExpensiveData());
}
// If you want to only collect data if somebody is listening at a specific
// level, you need to check both Enabled and Level. Note that the value of
// the Level is unspecified when Enabled is false.
if (channel.Enabled && channel.Level <= LoggingLevel.Warning)
{
channel.LogMessage(this.CollectExpensiveData(), LoggingLevel.Warning);
}
// The IsEnabled(LoggingLevel) method is a bit nicer than checking both
// Enabled and Level, but it is only available on Windows 10 or later.
if (channel.IsEnabled(LoggingLevel.Warning))
{
channel.LogMessage(this.CollectExpensiveData(), LoggingLevel.Warning);
}
// You can also use IsEnabled to check for keywords.
if (channel.IsEnabled(LoggingLevel.Information, 0x10))
{
channel.LogMessage(this.CollectExpensiveData(), LoggingLevel.Information);
}
// Use LoggingFields with the LogEvent method to write complex events.
var fields = new LoggingFields();
fields.AddDouble("pi", 3.14159);
channel.LogEvent(
"ComplexEvent",
fields,
LoggingLevel.Verbose,
new LoggingOptions(0x10)); // Keywords = 0x10
// You can add any number of name-value pairs to a fields object, though
// you may encounter ETW limitations if you add too many. For example,
// ETW is limited to a maximum event size of 64KB, and the current
// TraceLogging decoder can handle no more than 128 fields.
// Performance optimization: You can reuse a LoggingFields object to
// avoid unnecessary allocations. Don't forget to call Clear()
// between uses, and don't try to share a LoggingFields object between
// threads.
fields.Clear();
fields.AddDateTime("Date", DateTimeOffset.Now);
channel.LogEvent("Now", fields);
fields.Clear();
// You can add a formatting hint to affect the way a value is decoded.
// Not all combinations are useful, and the hint may be ignored.
// For example, you can encode an MBCS string by writing a byte array
// with a String hint.
fields.AddUInt8Array(
"AnsiString",
new byte[] { 65, 66, 67, 49, 50, 51 }, // "ABC123"
LoggingFieldFormat.String);
// You can add "tag" bits to a field. These are user-defined bits that
// can be used to communicate with an event processing tool. For example,
// you might define a tag bit to indicate that a field contains private
// data that should not be displayed on-screen.
fields.AddString("Password", "12345", LoggingFieldFormat.Default, 0x10);
// You can add a "structure" to an event. A structure is a name for a
// group of fields. Structures can nest. Call BeginStruct to add a level
// of nesting, and call EndStruct after the last field of the structure.
fields.BeginStruct("Nested");
fields.AddInt16("Nested-1", 1);
fields.AddInt16("Nested-2", 2);
fields.BeginStruct("Nested-Nested");
fields.AddInt16("Nested-Nested-3", 3);
fields.EndStruct();
fields.AddInt16("Nested-4", 4);
fields.EndStruct();
// Advanced scenarios: you can use a LoggingOptions object to control
// detailed event settings such as keywords, opcodes, and activity Ids.
// These have their normal ETW semantics. You can also set event tags,
// which are bit values that can be used to communicate with the event
// processor.
channel.LogEvent(
"VeryComplexEvent",
fields,
LoggingLevel.Information,
new LoggingOptions { Keywords = 0x123, Tags = 0x10 });
// Windows 10 introduces the ILoggingTarget interface. LoggingChannel
// implements this interface. This interface allows components to accept
// a logger as an parameter.
this.DoSomething(channel);
/*
If a LoggingActivity is created using a LoggingActivity constructor,
it will use Windows 8.1 semantics:
- If an activity is destroyed (garbage-collected) without being closed
and the associated LoggingChannel is still open, the activity will
write a default Stop event.
- The default Stop event (written by the destructor or by the Close()
method) is encoded as a "simple" event.
The 8.1 semantics are deprecated because the automatic generation of
a Stop event at garbage-collection can be misleading. The Stop event
is intended to mark the a precise point at which an activity is
completed, while the garbage-collection of an abandoned activity is
inherently imprecise and unpredictable.
If a LoggingActivity is created using a StartActivity method, it will
use Windows 10 semantics:
- If an activity is destroyed (garbage-collected) without being closed,
there will be no Stop event for the activity.
- The default Stop event (written by the Close() method) is encoded as
a TraceLogging event with name "ActivityClosed".
*/
// This activity is created with Windows 8.1 semantics.
using (var a1 = new LoggingActivity("Activity1", channel))
{
// The activity Start event is written by the LoggingActivity constructor.
// You would do your activity's work here.
// The activity Stop event is written when the activity is closed (disposed).
// The Windows 10 LoggingActivity adds new methods for writing events
// that are marked as associated with the activity.
a1.LogEvent("Activity event");
// LoggingActivity also implements the ILoggingTarget interface, so you can
// use either a channel or an activity as a logging target.
this.DoSomething(a1);
// The Windows 10 LoggingActivity adds new methods for creating nested activities.
// Note that nested activities are always created with Windows 10 semantics,
// even when nested under an activity that is using Windows 8.1 semantics.
using (var a2 = a1.StartActivity("Activity2"))
{
// Nested task occurs here.
// The Windows 10 LoggingActivity allows you to customize the Stop event.
a2.StopActivity("Activity 2 stop");
}
// Because a1 is using Windows 8.1 semantics, if we did not call Dispose(),
// it would attempt to write a Stop event when it is garbage collected.
// Writing Stop events during garbage collection is not useful, so be sure
// to properly stop, close, or dispose activities.
}
// The Windows 10 StartActivity method creates a new activity, optionally with
// specified fields and characteristics.
// This activity is created with Windows 10 semantics.
using (var a3 = channel.StartActivity("Activity3"))
{
// Because a3 is using Windows 10 semantics, if we did not call Dispose(),
// there would be no Stop event (not even when the activity is garbage
// collected). To get a Stop event, be sure to stop, close, or dispose the
// activity.
}
}
public static void Log(string message)
{
#if !UNITY_EDITOR
portalLogger.LogMessage(message, LoggingLevel.Information);
#endif
}
/// <summary>
/// This method demonstrates the LoggingChannel and LoggingActivity APIs.
/// </summary>
/// <param name="channel">
/// The channel to use for the demonstration. This channel may have been
/// constructed using a Windows 8.1 constructor or a Windows 10 constructor.
/// The same APIs are supported in both cases, but the ETL events will be
/// formatted a bit differently depending on how the channel was constructed.
/// </param>
private void DemonstrateLogging(LoggingChannel channel)
{
// Whenever any ETW session changes the way it is listening to this
// channel, the LoggingEnable event is fired. For example, this might
// be called when a session begins listening, changes the level at
// which it is listening, or stops listening.
channel.LoggingEnabled += this.OnLoggingEnabled;
// Log simple string events
channel.LogMessage("Simple message"); // default level is Verbose
channel.LogMessage("Simple error", LoggingLevel.Error);
// Log simple string + integer events.
channel.LogValuePair("Simple message", 123); // default level is Verbose
channel.LogValuePair("Simple error", 456, LoggingLevel.Error);
// The channel.Name property returns the name that was used when the
// channel was constructed. When running in Windows 10 mode, the name
// is already set as the provider name, so no LoggingChannelName is
// automatically added to the event.
channel.LogMessage(channel.Name);
// The channel.Id property is new to Windows 10.
channel.LogMessage(channel.Id.ToString());
// If you want to avoid the overhead of collecting data when nobody is
// listening to your channel, check the Enabled property before logging.
if (channel.Enabled)
{
channel.LogMessage(this.CollectExpensiveData());
}
// The IsEnabled() method is exactly the same as the Enabled property,
// except that it is a new Windows 10 API.
if (channel.IsEnabled())
{
channel.LogMessage(this.CollectExpensiveData());
}
// If you want to only collect data if somebody is listening at a specific
// level, you need to check both Enabled and Level. Note that the value of
// the Level is unspecified when Enabled is false.
if (channel.Enabled && channel.Level <= LoggingLevel.Warning)
{
channel.LogMessage(this.CollectExpensiveData(), LoggingLevel.Warning);
}
// The IsEnabled(LoggingLevel) method is a bit nicer than checking both
// Enabled and Level, but it is only available on Windows 10 or later.
if (channel.IsEnabled(LoggingLevel.Warning))
{
channel.LogMessage(this.CollectExpensiveData(), LoggingLevel.Warning);
}
// You can also use IsEnabled to check for keywords.
if (channel.IsEnabled(LoggingLevel.Information, 0x10))
{
channel.LogMessage(this.CollectExpensiveData(), LoggingLevel.Information);
}
// Use LoggingFields with the LogEvent method to write complex events.
var fields = new LoggingFields();
fields.AddDouble("pi", 3.14159);
channel.LogEvent(
"ComplexEvent",
fields,
LoggingLevel.Verbose,
new LoggingOptions(0x10)); // Keywords = 0x10
// You can add any number of name-value pairs to a fields object, though
// you may encounter ETW limitations if you add too many. For example,
// ETW is limited to a maximum event size of 64KB, and the current
// TraceLogging decoder can handle no more than 128 fields.
// Performance optimization: You can reuse a LoggingFields object to
// avoid unnecessary allocations. Don't forget to call Clear()
// between uses, and don't try to share a LoggingFields object between
// threads.
fields.Clear();
fields.AddDateTime("Date", DateTimeOffset.Now);
channel.LogEvent("Now", fields);
fields.Clear();
// You can add a formatting hint to affect the way a value is decoded.
// Not all combinations are useful, and the hint may be ignored.
// For example, you can encode an MBCS string by writing a byte array
// with a String hint.
fields.AddUInt8Array(
"AnsiString",
new byte[] { 65, 66, 67, 49, 50, 51 }, // "ABC123"
LoggingFieldFormat.String);
// You can add "tag" bits to a field. These are user-defined bits that
// can be used to communicate with an event processing tool. For example,
// you might define a tag bit to indicate that a field contains private
// data that should not be displayed on-screen.
fields.AddString("Password", "12345", LoggingFieldFormat.Default, 0x10);
// You can add a "structure" to an event. A structure is a name for a
// group of fields. Structures can nest. Call BeginStruct to add a level
// of nesting, and call EndStruct after the last field of the structure.
fields.BeginStruct("Nested");
fields.AddInt16("Nested-1", 1);
fields.AddInt16("Nested-2", 2);
fields.BeginStruct("Nested-Nested");
fields.AddInt16("Nested-Nested-3", 3);
fields.EndStruct();
fields.AddInt16("Nested-4", 4);
fields.EndStruct();
// Advanced scenarios: you can use a LoggingOptions object to control
// detailed event settings such as keywords, opcodes, and activity Ids.
// These have their normal ETW semantics. You can also set event tags,
// which are bit values that can be used to communicate with the event
// processor.
channel.LogEvent(
"VeryComplexEvent",
fields,
LoggingLevel.Information,
new LoggingOptions {
Keywords = 0x123, Tags = 0x10
});
// Windows 10 introduces the ILoggingTarget interface. LoggingChannel
// implements this interface. This interface allows components to accept
// a logger as an parameter.
this.DoSomething(channel);
/*
* If a LoggingActivity is created using a LoggingActivity constructor,
* it will use Windows 8.1 semantics:
*
* - If an activity is destroyed (garbage-collected) without being closed
* and the associated LoggingChannel is still open, the activity will
* write a default Stop event.
* - The default Stop event (written by the destructor or by the Close()
* method) is encoded as a "simple" event.
*
* The 8.1 semantics are deprecated because the automatic generation of
* a Stop event at garbage-collection can be misleading. The Stop event
* is intended to mark the a precise point at which an activity is
* completed, while the garbage-collection of an abandoned activity is
* inherently imprecise and unpredictable.
*
* If a LoggingActivity is created using a StartActivity method, it will
* use Windows 10 semantics:
*
* - If an activity is destroyed (garbage-collected) without being closed,
* there will be no Stop event for the activity.
* - The default Stop event (written by the Close() method) is encoded as
* a TraceLogging event with name "ActivityClosed".
*/
// This activity is created with Windows 8.1 semantics.
using (var a1 = new LoggingActivity("Activity1", channel))
{
// The activity Start event is written by the LoggingActivity constructor.
// You would do your activity's work here.
// The activity Stop event is written when the activity is closed (disposed).
// The Windows 10 LoggingActivity adds new methods for writing events
// that are marked as associated with the activity.
a1.LogEvent("Activity event");
// LoggingActivity also implements the ILoggingTarget interface, so you can
// use either a channel or an activity as a logging target.
this.DoSomething(a1);
// The Windows 10 LoggingActivity adds new methods for creating nested activities.
// Note that nested activities are always created with Windows 10 semantics,
// even when nested under an activity that is using Windows 8.1 semantics.
using (var a2 = a1.StartActivity("Activity2"))
{
// Nested task occurs here.
// The Windows 10 LoggingActivity allows you to customize the Stop event.
a2.StopActivity("Activity 2 stop");
}
// Because a1 is using Windows 8.1 semantics, if we did not call Dispose(),
// it would attempt to write a Stop event when it is garbage collected.
// Writing Stop events during garbage collection is not useful, so be sure
// to properly stop, close, or dispose activities.
}
// The Windows 10 StartActivity method creates a new activity, optionally with
// specified fields and characteristics.
// This activity is created with Windows 10 semantics.
using (var a3 = channel.StartActivity("Activity3"))
{
// Because a3 is using Windows 10 semantics, if we did not call Dispose(),
// there would be no Stop event (not even when the activity is garbage
// collected). To get a Stop event, be sure to stop, close, or dispose the
// activity.
}
}
