window.appInsights = appInsights;
        // Add telemetry initializer
        appInsights.queue.push(function () {
        appInsights.context.addTelemetryInitializer(function (envelope) {
          envelope.tags["ai.location.ip"] = "0"; //0 to hide or an IP address to resolve to location
        });
        });
        // end of insertion
        appInsights.trackPageView();

1. Create a telemetry processor, let's call it ConfigurableAdaptiveSamplingTelemetryProcessor. This is the code that you can you can just add to your project.
2. Replace AdaptiveTelemetryProcessor in your ApplicationInsights.config with ConfigurableAdaptiveSamplingTelemetryProcessor from your assembly. In my case I only would like to sample requests and dependencies, and always sent all other telemetry types:

 <!--
 <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.AdaptiveSamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">
   <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>
 </Add>
 -->
 <Add Type="Microsoft.ApplicationInsights.Samples.ConfigurableAdaptiveSamplingTelemetryProcessor, <YourAssemblyName>">
   <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>
   <SampledTelemetry>Request;Dependency</SampledTelemetry>
 </Add>

window.appInsights = appInsights;
// Add telemetry initializer
appInsights.queue.push(function () {
appInsights.context.addTelemetryInitializer(function (envelope) {
if (envelope.name === Microsoft.ApplicationInsights.Telemetry.PageView.envelopeType){
   envelope.data.baseData.url = "[stripped_url]";
 }
});
});
// end of insertion
appInsights.trackPageView();

window.appInsights = appInsights;
// Add telemetry initializer
appInsights.queue.push(function () {
appInsights.context.addTelemetryInitializer(function (envelope) {
envelope.tags["ai.operation.id"] = "my-op-id";
envelope.tags["ai.operation.name"] = "my-op-name";
 });
});
// end of insertion
appInsights.trackPageView();

Filtering data

window.appInsights = appInsights;
// Add telemetry initializer
appInsights.queue.push(function () {
appInsights.context.addTelemetryInitializer(function (envelope) {
if (envelope.name === Microsoft.ApplicationInsights.Telemetry.PageViewPerformance.envelopeType){
   return false;
 }
});
});
// end of insertion
appInsights.trackPageView();

Step 1. Install Application Insights

Step 2. Install ApplicationInsights.Stream Nuget

Step 3. Update aistream:key property in web.config

Step 4. Verify and deploy

1. Click edit on top of startboard
2. Bring up tile gallery
3. Order resources by type
4. Select Application Insights
5. Select your Application Insights resource
6. Scroll all the way down to find Application Map
7. Drag it your starboard
8. Click Done to finish editing startboard

Decision Tree

Are you seeing no data at all or just specific data types missing?

What telemetry types should I expect (and not expect) to see?

• Requests: You should expect requests if you onboarded to Web SDK for ASP.NET or ASP.NET v5 SDK.
• PageViews/ClientPerformance: To get PageViews and ClientPerformance you need to onboard to our JavaScript SDK by inserting a snippet into your master page.
• Exceptions: You can get unhandled exceptions automatically collected by Web SDK and JavaScript SDK is automatically collecting script errors
• Check our documentation for more information on dependencies, performance counters, events and metrics, and traces.

What if I don't see ANY telemetry?

Check telemetry items in VS debug output window

Check Application Insights references and configuration

• Microsoft.ApplicationInsights
• Microsoft.AI.Web
• Microsoft.AI.WindowsServer
• Microsoft.AI.ServerTelemetryChannel
• Microsoft.AI.PerfCounterCollector
• Microsoft.AI.DependencyCollector
• Microsoft.AI.Agent.Intercept.

Check with Fiddler that telemetry is sent successfully

Check ETW traces

Check latency issues with Application Insights backend

Contact us!

• Stack Overflow - use tag ms-application-insights
• MSDN Forums
• Use Disqus to post a clarifying questions to our documentation

Creating the project, opening the designer and adding/changing a few lines - initial impression was definitely positive - the XAML designer updates immediately, IntelliSense is working as expected. I even tried dragging something from the toolbox (something I haven't in a while with WPF, knowing it's often safer and always faster to just type it in) and it 'just worked'.

Well, unfortunately, despite having been impressed with IDE experience and designer responsiveness, eventually I ended up writing my  and testing application as a regular Silverlight project on different machine/VS instance and then moving it over to the VS 2010 Express for Windows Phone 7 and changing a few things. Reason being the deployment and connecting to emulator would literally take 3-5 minutes, so I would hit Ctrl+F5 and sit there waiting (or more likely switch to something else and forget what I was about to do). Luckily after my app worked on regular Silverlight, there was very little I had to change.

Edit App.xaml to change default styles.

I had to change default font size for my app, and found that the default styles and brushes, such as PhoneForegroundBrush and PhoneBackgroundBrush are in App.xaml.

<system:Double x:Key="PhoneFontSizeNormal">26</system:Double>

My app uses Purdy Points algorithm (that I borrowed from here) to predict race pace, based on past running performance.  BTW, If you are runner and/or would like to know more about Purdy Points, here's the website, it also has a proper calculator that provides more data.

On an emulator my app looked like this:

TextBox.InputScope

For my time input text boxes I wanted the number keypad appear when they get focus.

Then I came across this forum topic. InputScope property determines the context for the input. Actually I also expected it to restrict the input to whatever context it is set, i.e. in my case I would have liked it to restrict input to numeric characters. However it is not part of InputScope functionality, so I had to implement filtering myself. At first I tried to set InputScope as part of style for my TextBox:

but it would crash inside InitializeComponent() with a parsing exception missing any additional information. It works though when it is not part of style definition. Anyway, in my case I set it in code, because I subclassed the TextBox to implement custom focus and filtering behavior.

InputScope = new InputScope();
InputScope.Names.Add(new InputScopeName() { NameValue = InputScopeNameValue.Number});

Microsoft.Phone.Controls.ListView

Initially I used ListBox to display the results and then noticed that there's a new ListView control in Microsoft.Phone.Controls.dll. ListView inherits from ListBox (same as in WPF) so I in theory all I had to do was to change my tags in xaml from ListBox/ListBoxItem to ListView/ListViewItem. But when I attempted to bind the control to the collection, it failed to render leaving me with the following mysterious output.

For now I switched it back to using ListBox, but I'll look into this later and will post update to this blog when I find the issue.

Zipped SLN, references and acknowledgments 

1. Complete zipped solution: https://bit.ly/98DhVr 
2. Windows Phone 7 Developer Tools CTP download page: https://www.microsoft.com/downloads/details.aspx?FamilyId=2338b5d1-79d8-46af-b828-380b0f854203&displaylang=en
3. Purdy calculator algorithm: https://www.cs.uml.edu/~phoffman/xcinfo3.html

This is how MSDN explains the main user scenario for these notifications:

There are situations in which a full garbage collection by the common language runtime may adversely affect performance. This can be an issue particularly with servers that process large volumes of requests; in this case, a long garbage collection can cause a request time-out. To prevent a full collection from occurring during a critical period, you can be notified that a full garbage collection is approaching and then take action to redirect the workload to another server instance. You can also induce a collection yourself, provided that the current server instance does not need to process requests.

I decided to try them out and wrote a test WPF app that displays a message when full GC is about to start and then another message when full GC is complete. MSDN provides a decent sample that explains the usage pattern, but in a nutshell it is:

1. On the main thread call GC.RegisterForFullGCNotification(..)
2. Spawn a separate thread  that will call WaitForFullGCApproach and then WaitForFullGCComplete. In my case I was calling these methods with infinite timeout to keep it simple, so it would either return Succeeded or Canceled. Then I would send notification to the main thread that GC is either approaching or completed. Here's how 'GC notification procedure' looked.

        private void GCNotifyProc()
        {
            while (true)
            {
                var gcApproachStatus = GC.WaitForFullGCApproach(-1); //wait indefinitely
                if (gcApproachStatus == GCNotificationStatus.Succeeded)
                   //notify the main thread that full GC is imminent
                    Dispatcher.Invoke(new Action(() => NotifyGCStart()));
                else
                    // Main thread must have called GC.CancelFullGCNotification(..),
                    // or notification failed, exit the procedure
                    return;

                var gcCompleteStatus = GC.WaitForFullGCComplete(-1); //wait indefinitely
                if (gcCompleteStatus == GCNotificationStatus.Succeeded)
                    //notify the main thread that full GC has completed
                    Dispatcher.Invoke(new Action(() => NotifyGCComplete()));
                else
                    // Main thread must have called GC.CancelFullGCNotification(..),
                    // or notification failed, exit the procedure
                    return;
            }
        }

3. To stop listening for GC notifications, call GC.CancelFullGCNotification(..) from the main thread. At this point my background thread that was waiting inside WaitForFullGCApproach or WaitForFullGCComplete would return with GCNotificationStatus.Canceled and exit the procedure.

While this seems quite straightforward, I'd like to point out a few details that I learnt or realized while playing with GC notifications.

1. Concurrent GC needs to be disabled to use GC notifications. To disable add the following to your config file:
<configuration>
   <runtime>
       <gcConcurrent enabled="false"/>
   </runtime>
</configuration>
2. Full GC Notifications... are full GC notifications. Well, this is sure obvious, unless you, like me, forgot or wasn't sure what 'full' really means. Full GC means GC on Generation 2, while ephemeral GC means GC  on Generation 0 and 1. To recall, object is promoted to Gen2 after it has survided Gen1 GC with the exception of Large Object Heap objects that are bigger than 85K bytes and become part of Gen2 right from the start. So, this notification mechanism are for Gen2 collections only.
3. And finally, when WaitForFullGCApproach(..) returns Succeeded, all it means is that conditions for full GC are favourable and full GC is imminent. No guarantees are made about when exactly it will run. The name of the method reflects it clear enough, although I would probably make it sound even less deterministic.

My post was just scratching the surface, but if you're looking for more in-depth info on GC notifications, I'd recommend the following blog:  https://blogs.msdn.com/maoni/archive/2008/11/19/so-what-s-new-in-the-clr-4-0-gc.aspx