It took a long time reading various SO articles to find something that worked, but eventually found this (answer from Triplee).

Basically you need to run adb shell, run-as the package to impersonate the permissions, then use cat to pipe the file to another location on the device (sdcard which is available on the emulator), then use adb pull to copy to the host machine, so steps are:

1. Open adb command prompt (you can do this through Visual Studio)
2. adb shell
3. run-as com.package.name
4. cat foldername/dbfilename.db > /sdcard/dbfilename.db
5. exit
6. exit
7. adb pull /sdcard/dbfilename.db "c:\users\youruser\desktop\dbfilename.db"

Works nicely!

I tried it in Git Bash too and had the same results. I think when Visual Studio connects on Windows it must stash a token which it then uses to authenticate itself and never uses the Microsoft account username and password.

Normally when I connect to GitHub or BitBucket using HTTPS, I only use a simple user name and password combiation so figured it must be possible, but not with the Microsoft email address. After a fair amount of googling, I discovered that there is the concept of Alternate authentication credentials

If you login to .visualstudio.com and click Manage security next to the repository:

You get the security menu where you can select Alternate authentication credentials:

In here, you can create your Alternate authentication credentials:

Once saved, the .visualstudio.com Git repository can be cloned either from Git or Visual Studio for Mac using these credentials.

AppResource.cs-CZ.resx
AppResource.es-ES.resx
...etc

The resource files were set with the following build properties:

Build Action: Embedded Resource
Copy to Output Directory: Do not copy
Custom Tool: PublicResXFileCodeGenerator

In debug mode, the resources loaded fine and my localised text was appearing in the UI. however when built in Release mode, the resources we not loading and the default .resx (English) was being used.

After lots of messsing around with various settings, I remembered that a previous build had worked with a test Spanish file:

AppResource.es.resx

Now this file didn't have a Spanish variation but it worked.

Removing the language variations from the ends worked for release mode! Unfortunately I wanted simlified and traditional Chinese, so had to settle for just siplified.

Because on most pages it's not needed, the flyout master page is not wanted, but can be opened by swiping from the left margin.

There is a property on the control called IsGestureEnabled which should control whether the swipe gesture works or not, so I decided to apply it once and only have a button on the page control the IsPresented property to show and hide the master page.

This works fine on iOS, but not on Android. Initially the gesture is disabled, but as soon as the property changes, the gestures become active and start allowing swipe from left top open, once closed. I've not looked at the DrawerLayout, but I'm assuming the gestures are enabled to allow the user to swipe close, however the state is not reverted afterwards.

I had a look at the Renderer code and noticed on the IsGestureChanged property handling in the HandlePropertyChanged method, it calls onto a method called SetGestureState which sets the drawer locker mode:

void SetGestureState()
{
    SetDrawerLockMode(_page.IsGestureEnabled ? LockModeUnlocked :         LockModeLockedClosed);
}

So at first I was thinking I'd create a custom renderer to try and permenantly disable the gestures, but then I realised if we just toggle the IsGestureEnabled property, to make the property change and the method will get called and lock the drawer close.

I hooked the toggling onto the IsPresentedChanged event in the code-behind of my MasterDetailPage instance like this:

// Hack to re-disable drawer after close. Calls SetDrawerLockMode on Android
if(Device.RuntimePlatform == Device.Android)
{
    IsPresentedChanged += (s, e) =>
    {
        if (IsPresented) return;

        IsGestureEnabled = true;
        IsGestureEnabled = false;
   };
}

...and it works great!

I checked to make sure there were no updates in Visual Studio Tools/Extensions and Updates manager and there were none. So was still puzzled.

I thought maybe VS wasn't showing what was in the platforms folder:

C:\Program Files (x86)\Android\android-sdk\platforms

So I went and renamed some of my older SDKs and sure enough, the renamed folders disappeared, so it was reading the SDK versions OK.

So maybe there was a VS update I wasn't getting? After a bit of googling I found that you can manually check for an update via the VS installer:

• Locate the installer under Apps & Features
• Click Modify
• If there is an update available the Update button will be available

Once updated the new SDKs appeared :-)

    The file "obj\Debug\android\bin\packaged_resources" does not exist.

Removing the dash and removing, ore replacing with an underscore fixed the problem.

The Error

The application works fine locally, but when I publish and create a Click-Once deployment, the application was not launching and I was getting this error in the Windows EventViewer:

Application: My.App.exe Framework Version: v4.0.30319 Description: The process was terminated due to an unhandled exception. Exception Info: System.DllNotFoundException at Microsoft.Data.Sqlite.Interop.NativeMethods.sqlite3_open_v2(IntPtr, Microsoft.Data.Sqlite.Interop.Sqlite3Handle ByRef, Int32, IntPtr) at Microsoft.Data.Sqlite.Interop.NativeMethods.sqlite3_open_v2...

This means that the interop DLLs can't find the native SQLite DLLs, so can't run.

I've installed EntityFramework.Sqlite NuGet packages which has Microsoft.Data.Sqlite as a pre-requisite containing the SQLite interop. If we take a look in the packages folder, we can see the native DLLs live under the runtimes folder:

Now, if we look in our project target directory, we notice there is an x86 and x64 sub-directory with these DLLs in:

Now, when we look in the deployed click-once application which will be in a directory like this:

C:\Users\geoff\AppData\Local\Apps\2.0\WPBJ2B04.BKA\PN5A1WW5.2WE\ques..tion_7b7f6e03bc292b23_0001.0000_24569b1cbc6fe91b

The x86 and x64 directories are missing, in fact the DLLs aren't even in the root.

Solution

The solution is simple. We just need to deploy the x86 and x64 directories with the other published binaries. To do this we do the following:

• Add an x86 and an x64 folder to the visual studio project
• Link the native binaries from the package folder (you could add them if you wanted):
• We can see that these DLLs will be deployed before we publish, opening the project properties, then clicking Application Files on the Publish tab: Now when we publish and run the app, the native DLLs are available and it launches fine.

I installed (upgrade keeping files/apps rather than clean install) Windows 10 on my work machine on Thursday night last week, then found on Friday my existing VPN connection failed with a message like "Application not found" and the OS went off to the Windows Store to look for my VPN!

I deleted the existing VPN connection and created a new one, only to receive "A certificate chain processed, but terminated in a root certificate which is not trusted by the trust provider" - I've seen this issue before on my machine after a crash and Windows not shutting down properly - I managed to fix it by rolling back to a system restore point, however the machine is on a new operating system!

Luckily, there is an option in Updates & Security/recovery to "Go back to Windows 8.1" (or whatever OS it came from) this option is available for month as lone as long as disk cleanup utility hasn't been run to remove previous installation files. I returned the machine to 8.1 which took about 1/2 an hour and started fine, although I still got the root certificate error again.

I was preparing myself to spend all weekend re-paving my machine, but remembered the problem I'd had previously and looked in System Restore (Type recovery on Win 8.1 start screen, then go to "Open System Restore"). Luckily there we still some restore points and I was able to restore to a point just before installing Windows 10.

After another hour or so, the OS was restored to before Windows 10 and my VPN connected fine and I was able to work again!

For a simple select statement to return the IDs from a table like this:

var ctx = new DemoContext();
var item = ctx.Line.Select(l => l.ID).ToList();

The following SQL is executed

SELECT 
[Extent1].[ID] AS [ID]
FROM [dbo].[Line] AS [Extent1]    

We can see that only the ID field is returned.

Now another example, where we are projecting the results into an anonymous object:

var item = ctx.Line.Select(l => new { id = l.ID, name = l.Name }).ToList();

And the resultant SQL:

SELECT 
1 AS [C1], 
[Extent1].[ID] AS [ID], 
[Extent1].[Name] AS [Name]
FROM [dbo].[Line] AS [Extent1]    

Here we get the fields required for the anonymous object and an extra C1 field which is a dummy PK for the object.

It took a bit of working out from various sources how to do it. It's actually really simple. Before the param declaration in the function, simply add this cmdltbinding:

[cmdletbinding(SupportsShouldProcess=$True)]

And the -whatIf (and -confirm) switch is passed through the pipeline to the commandlets.

So the function looks like this:

function copy-Files
{
    [cmdletbinding(SupportsShouldProcess=$True)]
    param(
        $myParam        
    )
    # Function here
}

That's it!

error 0x800b0109 a certificate chain processed but terminated in a root certificate

I tried recreating it a number of times and rebooting machine etc, but still seeing same error whatever I did.

I think the error is indicating that a certificate is not installed on the machine...I suspect it might have been corrupted.

Anyway, my fix was to simply restore my machine to a point 2 days previous before the issue occurred using System Restore: http://windows.microsoft.com/en-GB/windows-8/restore-refresh-reset-pc

This is the Preface, which gives you a good idea of what's in the book:

Learning Microsoft Azure is a practical, hands-on book for learning how to build systems for Microsoft Azure. The book is themed around an enterprise case study based on a fictional industrial bakery called Azure Bakery which spans 3 business units: Sales, Production and Supply. The entire system is built on Microsoft Azure technology utilizing a broad range of services.

The Sales business unit is responsible for selling products to customers through the MVC5 Customer website where customers can make orders and view their status as the order moves through the system. Products are managed through another administrator website which implements Azure Active Directory authentication. A Windows Phone app with .Net Mobile service and Twitter authentication integrated with the Customer website allows customers to view order status on their phone and receive push notifications via the Notifications Hub when order status changes and new products are created. The Sales system has its own dedicated SQL Azure database and communicates with the other systems via a Service Bus Topic. A worker role is implemented to keep the Sales system updated as orders are processed through the enterprise system.

The Production business unit is responsible for manufacturing the products for the customer orders and has a worker role at the core of it which consumes customer orders from the Service Bus Topic, enters the orders into the Production SQL Azure database, creates batch schedules for baking products and allocates stock in the system. Production staff use an on-premises WPF client application with Azure Active Directory authentication to view batch schedules and manage stock via a Web API 2 service with SignalR hub and Azure Service Bus backplane allowing client applications to update in real-time.

The Supply business unit is responsible for picking and packing orders from the Production business unit and delivering them to the customers. A worker role consumes orders from the Service Bus Topic and stores customer details in Table Storage and automatically creating barcode labels stored in BLOB storage. Supply staff interact with the system via an Enterprise Windows Store app which is authenticated with Azure Active Directory and has a .Net Mobile Service backend.
As we’re building the system we learn about the topic we’re exploring and apply it to our system with detailed walk-throughs and relevant code samples. There are full working code samples for the entire system broken down chapter-by-chapter.
What this book covers

Chapter 1 - Getting Started with Microsoft Azure

An introduction to cloud computing and Microsoft Azure followed by how to choose a subscription and signing up for a subscription. We finish the chapter with a look around the portal and start looking at the different services Microsoft Azure has to offer.

Chapter 2 - Designing a System for Microsoft Azure

Designing scalable resilient systems for Microsoft Azure looking at methodologies for breaking systems into sub-systems and selecting appropriate Azure services to build them. The process will be applied to designing a small system for an independent stationers requiring a website and basic administration system, then extended to a full enterprise system where will we introduce the Azure Bakery case study.

Chapter 3 - Starting Developing with Microsoft Azure

This is the first taste of developing for Microsoft Azure, where the reader will prepare their development environment with the required tools and sign-up for a Visual Studio online account. We’ll create the foundations of the Sales Customer website and publish it to the cloud, then setup continuous deployment using Visual Studio Online Team Foundation build.

Chapter 4 - Creating and Managing an Azure SQL Server Database

We’ll create a database for the Sales business unit and build it using Entity Framework Code-First migrations. The chapter will examine different tools for working with the database from a developer and administrator point of view and look at options for database backup.

Chapter 5 - Building Azure MVC Websites

In this chapter the Sales Customer website and Administrator website are built with Twitter authentication for the Customer site and Azure Active Directory authentication for the Administrator site. We learn how to apply custom domain names and SSL certificates to Azure websites and learn how to do Azure AD group authorization in an MVC website.

Chapter 6 - Azure Website Diagnostics and Debugging

This chapter follows on from the previous chapter, exploring techniques and tools to help diagnose problems and debug Azure websites. We’ll look at enabling diagnostics in websites, working with log files and examining application logging and site diagnostics. Finally we’ll look at the Kudu service and remote debugging Azure websites.

Chapter 7 - Azure Service Bus Topic Integration

Starting with an overview of Service Bus Topics and creating a Topic for handling order messaging between the 3 business tiers, we’ll integrate the Sales Customer website into the Topic with a Subscription allowing newly created orders to be sent across the system where they wil be collecte by the Production system for manufacturing and the Supply system for producing address labels and planning deliveries. We’ll also create a messaging simulator created to allow the Topic to be loaded-up with high volumes of orders to help test the scalability and capacity of the system. Finally we’ll look at the features in the portal to help us monitor and manage our Service Bus Topic.

Chapter 8 - Building Worker Roles

After an introduction to cloud services and creating a worker role, we’ll create and run a basic cloud service locally on the compute emulator, then publish and run it in cloud. The Production Order processor is created next, which is responsible for receiving orders from the service Bus Topic, saving them to the Production database and creating product batch schedules and allocating stock. Finally we’ll test the cloud service in a scaled deployment using the simulator created in Chapter 7.

Chapter 9 - Cloud Service Diagnostics, Debugging and Configuration

This chapter follows on from the previous chapter, covering diagnostics, remote debugging and Intellitrace. We’ll learn how to deal with configuration changes made in the portal at runtime and implement startup tasks for performing customisations for preparing the server environment for the service.

Chapter 10 - Web API and Client Integration

An introduction to Web API and Signal R with an Azure Service Bus backplane followed by building a Web API Service and SignalR hub to allow the Production Management application to interact with the Production database and Service Bus Topic. The system will be authenticated with Azure AD authentication allowing production staff to login to the WPF client application using their Azure AD credentials.

Chapter 11 - Integrating a Mobile Application using Mobile Services

This chapter brings the whole system together with the addition of a Mobile Service and Windows Phone 8 application for the Sales system which allows users to login with the same credentials as the Customer website, view orders and receive order updates and product news via the Notifications Hub. The sales Mobile Service provides APIs for the Admin website and Order processor to interact with the Notifications Hub. Finally the chapter looks at building an Azure AD authenticated Mobile Service for the Supply Windows Store application for viewing orders and retrieving address labels from BLOB storage created by the Supply Order Processor.

Chapter 12 - Preparing and Azure System for Production

This final chapter looks at configuring systems for various environments including production and creating publishing packages using Visual Studio Online Team Foundation build server and producing database scripts in order for the system deployments to be managed in a controlled way by systems administrators or developers. We’ll learn about monitoring the different services implemented throughout the book once they are live and also cover guidelines for publishing web-connected mobile applications.

The Problem

In order to call the /login/aad endpoint locally we need to enable HTTPS on web server (IIS Express) and use the login URL like this https://localhost:12345/login/aad with the AuthenticationContext. The Windows Store Application doesn't like this endpoint as it's got a temporarly SSL certificate without a trusted root and we don't have the option to absorb untrusted certificates like we can in .Net clients using the ServicePointManager.ServiceCertificationValidationCallback like this:
ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => true;

So we get an exception with message: The underlying connection was closed. Could not establish trust relationship for the SSL/TLS secure channel when we call AuthenticationContext.AcquireTokenAsync.
I had a play about with the capabilities in the Package.appxmanifest to see if anything could be done to allow the certificate. I enabled "Shared User Certificate" which got rid of the exception, but then came back with an 401 Unauthorized exception on LoginAsync which I think is because this setting is for using an SSL cert for securing comms between the client and custom web services.

Possible Options

I don't think there is an easy way of easily getting this to work locally. We could apply a trusted SSL certificate to our local service, however this requires purchasing one in the first place and second requires additional configuration. The other option would be to create a temporary certicate and configure that on the local web server and configure certificates in the Package.appxmanifest which would need removing on publish.

Workaround

This was bugging me for a while and I was close to giving up and just debugging against Azure, but I suddenly though we might be able to authenticate against a published service on Azure, then use the credentials with a client pointing at our local service...well, it works!
First thing to do is publish the Mobil Service, then modify the web.config app settings. Use the same keys as the published service to save switching them in code:

<add key="MS_MasterKey" value="YYYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXxxxxxxxxxxxxxx" /> <add key="MS_ApplicationKey" value="YYYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXxxxxxxxxxxxxxx" />

These settings aren't well documented, but add these with the MSAadClient id being the AD application for the Azure service (see this example) and the MSAadTenants setting the AD tenant domain:

<!-- Manually add these --> <add key="MS_AadClientID" value="XXXXXXXXXXXyyyyyyyyyyy" /> <add key="MS_AadTenants" value="myservice.onmicrosoft.com" />

In my auth base class I have something like this at the top:

private const string authority = "https://login.windows.net/myapplication.onmicrosoft.com";
private const string clientID = "xxxxxxxxxxxxxYYYYYYYYYYYYY";

private const string azureUri = "https://myservice.azure-mobile.net";

private const string resourceURI = "https://myservice.azure-mobile.net/login/aad";

#if DEBUG
protected readonly static MobileServiceClient _mobileService = new MobileServiceClient(
    "http://localhost:58932/",
    "XXXXXXXXXXXXXXXyyyyyyyyyyyyyyyyy"
    );
#else
protected readonly static MobileServiceClient _mobileService = new MobileServiceClient(
    "https://myservice.azure-mobile.net",
    "XXXXXXXXXXXXXXXyyyyyyyyyyyyyyyyy"
    );
#endif

When we're in DEBUG mode, we're using the local URL (HTTP not HTTPS) which will allow us to debug the service once we've logged into out AD Tenant.
Not at the login step, if we're in DEBUG mode, we quickly new-up a MobileServiceClient pointing to the published Mobile Service, login, the copy the user object into our static MobileServiceClient to be used by all classes implementing the base class:

var ac = new AuthenticationContext(authority);
var ar = await ac.AcquireTokenAsync(resourceURI, clientID);
var payload = new JObject();
payload["access_token"] = ar.AccessToken;

MobileServiceUser user = null;
#if DEBUG
// Create temp client to loging to azure service, then pass user to local client
var client = new MobileServiceClient(azureUri, _mobileService.ApplicationKey);
user = await client.LoginAsync(_provider, payload);

// Swap user
_mobileService.CurrentUser = user;
#else
// Login
user = await _mobileService.LoginAsync(_provider, payload);
#endif

Conclusion

This workaround is really simple to implement and works really well, it's not really exploiting a security loophole either because even though we're getting an authentication token from a different service, the local service is still validating the token against the AD application with the same identifiers as the published version.

Creating a VM

First of all we need to create a VM on Azure so login to the portal (I'm using the old portal as the new one isn't feature complete yet), go to the Virtual Machines workspace, then click the +NEW button in the toolbar and fill in the new VM details:

The size of the VM is quite important for a Neo4j server as we can scale-up (more CPU, memory etc) but not-scale-out (multiple instances) because the database engine can't currently partitioned.

Downloading Installers

Once the VM is created, click the CONNECT button on the VM workspace toolbar to download the RDP (Remote Desktop Protocol) shortcut which you can use to remote desktop to the server. Accept all the warnings an you should see the server desktop.
Go to the Neo4j download site and locate the zip version so we can install it as a service. It's a pain to download things on a sever as IE is quite tightly locked down, so the easiest way is to use the PowerShell BitsDownloader module. To do this, open PowerShell from the server desktop or start menu and enter the following command to load the module:
import-module bitstransfer Then enter a command like this to download from a URL to a location on the server: start-bitstransfer -source http://dist.neo4j.org/neo4j-community-2.1.2-windows.zip -destination c:\users\geoff\downloads\neo4j-community-2.1.2-windows.zip A nice progress indicator appears as the file downloads. My console looked like this:

Neo4j as the j suggests runs on JRE so we need to download that too. I got an installer from a mirror site as the Oracle link doesn't work with bittransfer due to the usage policy:
start-bitstransfer -source http://java64.net/download/jre-8u11-windows-x64.exe -destination c:\users\geoff\downloads\jre-8u11-windows-x64.exe

Installing the Service

Follow this procedure to install the service:

1. Extract the contents of the zip file and copy to where you want the service to run from
2. Open a command prompt (just type cmd on start screen)
3. Change directory to the neo4j bin folder and run Neo4jInstaller.bat install.
4. The service can be started with the following command:
   sc start neo4j-server
5. The service can be stopped with the following command:
   sc stop neo4j-server
6. By default it's set to start automatically when the server starts.
7. If we want to allow remote connections (which is highly likely)we need to allow the server to accept connections from remote machines so stop the service, then open the following config in notepad:
   conf\neo4j-server.properties
8. Find the following section:
   # Let the webserver only listen on the specified IP. Default is localhost (only # accept local connections). Uncomment to allow any connection. Please see the # security section in the neo4j manual before modifying this. #org.neo4j.server.webserver.address=0.0.0.0
9. Uncomment the last line and save the file:
   org.neo4j.server.webserver.address=0.0.0.0
10. If you want to change the port, you can do this here too
11. Start the service again
12. Test the browser page opens locally in the browser:
    http://localhost:7474/browser

Configuring the Server Firewall

We need to add a firewall rule to allow remote machines to connect to port 7474. Follow this procedure to do this:
1. Open Windows Firewall with Advanced Security from the Server Manager menu:

2. Click New Rule in the actions menu and select Port in the New Inbound Rule Wizard:

3. Click Next then enter the port number in the Specific local ports box:

4. Click Next 3 times, then enter a rule Name and click Finish:

Configuring an Endpoint

Now we've got the internal firewall setup systems on the internal Azure network can connect but if we want to connect from an external network, we need to configure a public endpoint so the Azure load ballancer will allow connections through. To configure an endpint follow this procedure:
1. In the Azure portal navigate to our VM in the Vitual Machine workspace and cliek on the ENDPOINTS tab, notice we have endpoints already configured for PowerShell and Remote Desktop (which is how we got in there in the first place!). Click add on the toolbar to add a new endpoint:
2. Leave the default ADD A STAND-ALONE endpoint as we can't load-balance the database:
3. Click the next arrow and fill in the name and ports:

4. Click the tick to finish
5. You should now be able to connect remotely in a browser with a url like this:
http://myvmname.cloudapp.net:7474/browser/

Configuring ACL

Now that we have an endpoint to connect to anybody on the internet can connect, so it's a good idea to lock it down to a selection of individual IP addresses or ranges of IP address using Access Control List.
We'll add ACL rules for individual IP addresses and IP ranges in the following proceedure:
1. Select the endpoint we just created and click MANAGE ACL on the toolbar:

2. Add a description and enter the single IP address with /32 to lock down the CIDR address to a single IP address range:

3. Next we'll add a range of addresses, I used this online tool to calculate the CIDR address from my IP range, then added that.
4. Finally add a Deny to all other addresses:

5. Test that the browser site still loads (it may take a while for the ACL permissions to take effect)
6. Test that a remote machine outside the permitted list can not see the site. It's important to put the Permit rules before the Deny rules otherwise they will not work.

Conclusion

We've had a good look at the different aspects of what is required to host a Neo4j database on Azure VM and it's been a worthwhile excercise in understanding how Neo4j is installed as a service, how to setup the server and how to configure the VM's Endpoints and ACL.

I did research into SLAB in the preperation for the book I'm writing for Packt Publishing called "Learning Microsoft Azure" but didn't have space in the diagnostics chapter so I'm writing about it here.

It’s a good idea to do an extra bit of reading on SLAB as it’s quite complicated and we’re going to go through the implementation quite quickly here. There is some good information and examples on the CodePlex site: http://entlib.codeplex.com/wikipage?title=Entlib6CTPReleaseNotes.
We’ll implement Entlib SLAB in an MVC5 website, deployed to Azure with Azure table storage for our trace sink in the following procedure:

Install the EnterpriseLibrary.SemanticLogging.WindowsAzure NuGet package with the following command in the Package Manager Console:

Install-Package EnterpriseLibrary.SemanticLogging.WindowsAzure

Create an EventSource class for the website (I called mine CustomerWebsiteEvents and put it in a folder called Instrumentation). The EventSource class contains EventKeywords, EventTypes and EventOpcodes which are used to decorate explicit event methods for every operation you wish to log (sorry this is bit long-winded but everything is in there, I've taken the indents out to make it slightly easier to read too):

using System;
using System.Diagnostics.Tracing;

namespace AzureBakery.Sales.CustomerWebsite.Instrumentation
{ [EventSource(Name = "CustomerWebsiteEvents")] public class CustomerWebsiteEvents : EventSource
{ public static class Keywords
{ public const EventKeywords Application = (EventKeywords)1L;
public const EventKeywords DataAccess = (EventKeywords)2L;
public const EventKeywords Controller = (EventKeywords)4L;
}

public static class Tasks
{ // For LogActionFilter public const EventTask Action = (EventTask)1;
public const EventTask Result = (EventTask)2;

// General public const EventTask Initialize = (EventTask)6;
public const EventTask GetProducts = (EventTask)7;
public const EventTask AddProductToOrder = (EventTask)8;
}

public static class Opcodes
{ public const EventOpcode Starting = (EventOpcode)20;
public const EventOpcode Started = (EventOpcode)21;
public const EventOpcode Error = (EventOpcode)22;

public const EventOpcode Ending = (EventOpcode)23;  
public const EventOpcode Ended = (EventOpcode)23;

public const EventOpcode Executed = (EventOpcode)30;  
public const EventOpcode Executing = (EventOpcode)31;  
}

public static readonly CustomerWebsiteEvents Log = new CustomerWebsiteEvents();

[Event(100, Level = EventLevel.Verbose, Keywords = Keywords.Application, Task = Tasks.Initialize, Opcode = Opcodes.Starting, Version = 1)]
public void ApplicationStarting()  
{
if (this.IsEnabled(EventLevel.Verbose, Keywords.Application))  
{
this.WriteEvent(100);  
}
}

[Event(101, Level = EventLevel.Informational, Keywords = Keywords.Application, Task = Tasks.Initialize, Opcode = Opcodes.Started, Version = 1)]
public void ApplicationStarted()  
{
if (this.IsEnabled(EventLevel.Informational, Keywords.Application))  
{
this.WriteEvent(101);  
}
}

[Event(102, Level = EventLevel.Error, Keywords = Keywords.Application, Opcode = Opcodes.Error, Version = 1)]
public void ApplicationError(string exceptionMessage, string exceptionType)  
{
if (this.IsEnabled(EventLevel.Error, Keywords.Application))  
{
this.WriteEvent(102, exceptionMessage, exceptionType);  
}
}

[Event(200, Level = EventLevel.Informational, Keywords = Keywords.Controller, Task = Tasks.Action, Opcode = Opcodes.Executing, Version = 1)]
public void ActionExecuting(string controller, string action)  
{
if (this.IsEnabled(EventLevel.Informational, Keywords.Controller))  
{
this.WriteEvent(200, controller, action);  
}
}

[Event(201, Level = EventLevel.Verbose, Keywords = Keywords.Controller, Task = Tasks.Action, Opcode = Opcodes.Executed, Version = 1)]
public void ActionExecuted(string controller, string action)  
{
if (this.IsEnabled(EventLevel.Verbose, Keywords.Controller))  
{
this.WriteEvent(201, controller, action);  
}
}

[Event(202, Level = EventLevel.Informational, Keywords = Keywords.Controller, Task = Tasks.Result, Opcode = Opcodes.Executing, Version = 1)]
public void ResultExecuting(string controller, string action)  
{
if (this.IsEnabled(EventLevel.Informational, Keywords.Controller))  
{
this.WriteEvent(202, controller, action);  
}
}

[Event(203, Level = EventLevel.Verbose, Keywords = Keywords.Controller, Task = Tasks.Result, Opcode = Opcodes.Executed, Version = 1)]
public void ResultExecuted(string controller, string action)  
{
if (this.IsEnabled(EventLevel.Verbose, Keywords.Controller))  
{
this.WriteEvent(203, controller, action);  
}
}        

[Event(200, Level = EventLevel.Informational, Keywords = Keywords.Controller, Task = Tasks.GetProducts, Opcode = Opcodes.Started, Version = 1)]
public void ProductControllerGetProductsStarted()  
{
if (this.IsEnabled(EventLevel.Informational, Keywords.Controller))  
{
this.WriteEvent(200);  
}
}

[Event(200, Level = EventLevel.Informational, Keywords = Keywords.Controller, Task = Tasks.GetProducts, Opcode = Opcodes.Ended, Version = 1)]
public void ProductControllerGetProductsEnded()  
{
if (this.IsEnabled(EventLevel.Informational, Keywords.Controller))  
{
this.WriteEvent(200);  
}
}

[Event(200, Level = EventLevel.Error, Keywords = Keywords.Controller, Task = Tasks.GetProducts, Opcode = Opcodes.Error, Version = 1)]
public void ProductControllerGetProductsError(Exception ex)  
{
if (this.IsEnabled(EventLevel.Error, Keywords.Controller))  
{
this.WriteEvent(200, ex);  
}
}

[Event(200, Level = EventLevel.Informational, Keywords = Keywords.Controller, Task = Tasks.AddProductToOrder, Opcode = Opcodes.Started, Version = 1)]
public void ProductControllerAddProductToOrderStarted()  
{
if (this.IsEnabled(EventLevel.Informational, Keywords.Controller))  
{
this.WriteEvent(200);  
}
}

[Event(200, Level = EventLevel.Informational, Keywords = Keywords.Controller, Task = Tasks.AddProductToOrder, Opcode = Opcodes.Ended, Version = 1)]
public void ProductControllerAddProductToOrderEnded()  
{
if (this.IsEnabled(EventLevel.Informational, Keywords.Controller))  
{
this.WriteEvent(200);  
}
}

[Event(200, Level = EventLevel.Error, Keywords = Keywords.Controller, Task = Tasks.AddProductToOrder, Opcode = Opcodes.Error, Version = 1)]
public void ProductControllerAddProductToOrderError(Exception ex)  
{
if (this.IsEnabled(EventLevel.Error, Keywords.Controller))  
{
this.WriteEvent(200, ex);  
}
}
}
}

Next we need to modify the Global.asax to setup the listeners (the settings are from appSettings in web.config which we'll cover in a second), I've also added some tracing for the application start and a global errors:

public class MvcApplication : System.Web.HttpApplication  
{
    void Application_Start()
    {
        this.SetupListeners();

        CustomerWebsiteEvents.Log.ApplicationStarting();

        base.Error += MvcApplication_Error;

        AreaRegistration.RegisterAllAreas();
        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);

        CustomerWebsiteEvents.Log.ApplicationStarted();
    }

    private void SetupListeners()
    {
    // Get log details from web config (these can be configured in website CONFIGURE tab)
    EventLevel logLevel = (EventLevel)Enum.Parse(typeof(EventLevel), ConfigurationManager.AppSettings["logLevel"]);
    var logAccountName = ConfigurationManager.AppSettings["logAccountName"];
    var logAccountKey = ConfigurationManager.AppSettings["logAccountKey"];
    var logTableName = ConfigurationManager.AppSettings["logTableName"];

    // Create listener and enable events
    var listener = new ObservableEventListener();
        listener.EnableEvents(CustomerWebsiteEvents.Log, logLevel, Keywords.All);

    // Build storage connection string
    var cnString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", logAccountName, logAccountKey);

    // Log listener to azure         listener.LogToWindowsAzureTable("WindowsAzureListener", cnString, logTableName);        
    }

    void MvcApplication_Error(object sender, EventArgs e)
    {
        CustomerWebsiteEvents.Log.ApplicationError(Server.GetLastError());
    }
}

As I mentioned, I've put all the table logging setting in the web config which can be modified in the portal if needed. Once we have a storage account, we can fill in the details:

<appSettings>  
    <add key="webpages:Version" value="3.0.0.0" />
    <add key="webpages:Enabled" value="false" />
    <add key="ClientValidationEnabled" value="true" />
    <add key="UnobtrusiveJavaScriptEnabled" value="true" />
    <!-- SLAB -->
    <add key="logAccountName" value="myAccountName" />
    <add key="logAccountKey" value="xxxxxxxxxxxxxxXXXXXXXXXXMyKey==" />
    <add key="logTableName" value="SalesCustomerLog" />
    <add key="logLevel" value="LogAlways" />
</appSettings>

Now, we can instrument our controllers and data access layer, here's an action from a controller:

[Authorize]
public ActionResult AddToOrder(int id)  
{                  CustomerWebsiteEvents.Log.ProductControllerAddProductToOrderStarted();

    OrderItem item = null;

    try
    {
        // Get customer details
        var uid = User.Identity.GetUserId();

        // Add to order
        item = this._uow.AddToOrder(id, uid);

        // Save
        this._uow.SaveChanges();
    }
    catch (Exception ex)
    {            CustomerWebsiteEvents.Log.ProductControllerAddProductToOrderError(ex);

        throw;
    }    
        CustomerWebsiteEvents.Log.ProductControllerAddProductToOrderEnded();

    return RedirectToAction("Index", new { productType = item.Product.ProductType });
}

Now if we publish the website, then excecise it in the browser and examine the table storage, we should see our application tracing being logged:

Manually creating methods for numerous controller actions can be quite time consuming so I put together an ActionFilterAttribute to log the controller action life-cycle events:

public class LogActionFilter : ActionFilterAttribute  
{
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        var controllerName = filterContext.RouteData.Values["controller"].ToString();
        var actionName = filterContext.RouteData.Values["action"].ToString();    
            CustomerWebsiteEvents.Log.ActionExecuted(controllerName, actionName);

        base.OnActionExecuted(filterContext);
    }

    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        var controllerName = filterContext.RouteData.Values["controller"].ToString();
        var actionName = filterContext.RouteData.Values["action"].ToString();    
            CustomerWebsiteEvents.Log.ActionExecuting(controllerName, actionName);

        base.OnActionExecuting(filterContext);
    }

    public override void OnResultExecuted(ResultExecutedContext filterContext)
    {
        var controllerName = filterContext.RouteData.Values["controller"].ToString();
        var actionName = filterContext.RouteData.Values["action"].ToString();
                CustomerWebsiteEvents.Log.ResultExecuted(controllerName, actionName);

        base.OnResultExecuted(filterContext);
    }

    public override void OnResultExecuting(ResultExecutingContext filterContext)
    {
        var controllerName = filterContext.RouteData.Values["controller"].ToString();
        var actionName = filterContext.RouteData.Values["action"].ToString();    
            CustomerWebsiteEvents.Log.ResultExecuting(controllerName, actionName);

        base.OnResultExecuting(filterContext);
    }
}

This can easily be added at controller level to achieve logging for all actions like this:

namespace AzureBakery.Sales.CustomerWebsite.Controllers  
{
    [LogActionFilter]
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }

Overall using EventSource and SLAB is extremely powerful for creating tailored tracing for websites compared with the standard System.Diagnostics.Trace object. We can create table logs which make it easy to pinpoint exactly the diagnostic information we're looking for by querying the EventId, Keyword, Type, OpCode and Level.