Hernan de Lahitte's blog

Your best friend for authoring ETW strongly typed events

2013-05-02T17:34:00Z

So you were reading some good tutorials on how to write your first typed event class but for some reason it may not work as expected? (Or many other issues as well)

As I wrote in my last post about the new Entlib 6.0, there is helping class in the Semantic Logging Application Block named EventSourceAnalyzer that will help you check your class for multiple potential issues that may be hard to diagnose.

Let's see how to write a very simple unit test that will do a full check of your class:

[TestMethod]

public void when_inspecting_myCompanyEventSource()

{

EventSourceAnalyzer.InspectAll(MyCompanyEventSource.Log);

}

As you can see, your custom class will implement a singleton (Log static method) so this instance will be used by the analyzer to perform many checks and throw an error if it finds something wrong or may not be well implemented according to the EventSource guideline.

This class also have an instance usage where you can turn on/off some knobs for adjust the check behavior to some custom scenarios. On of the performed checks is the type mapping between the event argument types and the WriteEvent call inside your event implementation.

A standard event may be defined as follow:

[Event]

public void GuidNotMapped(Guid id)

{

WriteEvent(1, id);

}

Now in case you want to use on of the defined overloads of WriteEvent and avoid the casting to the params object[] overload described in section 5.6.2 in StronglyTypedEvents doc then you may have something like this:

[Event]

public void GuidMappedToString(Guid id)

{

WriteEvent(1, id.ToString());

}

So in this case, you may use on of the provided knobs described above and bypass the type mapping check:

[TestMethod]

public void when_inspecting_myCompanyEventSource_with_typeMapping_off()

{

var analyzer = new EventSourceAnalyzer() { ExcludeWriteEventTypeMapping = true };

analyzer.Inspect(MyCompanyEventSource.Log);

}

I hope you can find the EventSourceAnalizer a good companion for your custom typed events.

Enterprise Library 6.0 is RTW (and Unity 3.0)

2013-04-26T15:35:00Z

Finally the latest version of Enterprise Library 6.0 (and almost a decade of evolution from the first block).

A great summary of all the new features along with some insights can be found in this post from Grigori.

My plan is to write a series of post with some additional information and samples of the brand new Semantic Logging Application Block which leverage the new typed events in NET 4.5 and the high performance ETW tracing infrastructure.

So I guess that if you are new to typed events in v4.5 and want to start authoring them, you may probably stop by Vance blog, an authority in this matter.

You will soon realize that creating a typed event class and start producing events is very easy. However is also easy to introduce hard to diagnose errors. So my first post about the "hidden" goodies in this new block (SLAB for friends) will let you know how you can get a good helping hand for authoring your custom EventSource classes.

One more link in codeplex with some discussion forums and additional links as well. Also Unity 3.0 has it's own MSDN page.

Stay tuned!

Enterprise Library 6.0 and Semantic Logging

2013-02-17T22:01:00Z

Finally the Semantic Logging CTP from Enterprise Library 6.0 is out.

In this blog post Grigori presents an insight overview of this new block along with some comments regarding how this blocks leverage the new features in NET 4.5 and ETW.

Here is the Release Notes that summarizes the goal of this block along with a great video that shows hot to use it.

In future post I will try to add some insight on the out-of-process mode that you can use SLAB (Semantic Logging Application Block).

Tracing to ETW with Enterprise Library v5

2012-11-13T17:40:00Z

While I was looking for a way to use ETW Tracing using the logging EntLib infrastructure, I found out that using a handy trace listener like SystemDiagnosticsTraceListenerData configured to use the built-in EventProviderTraceListener was all that I needed. With just setting the event provider ID which is simply a GUID added to the initializeData attribute and I'm good to go.

This is an example of the config section configured with the above settings:

<add listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.SystemDiagnosticsTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.505.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"

type="System.Diagnostics.Eventing.EventProviderTraceListener, System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"

traceOutputOptions="ThreadId" name="ETW Trace Listener" initializeData="{D2FAAB3F-5D61-42B5-A014-D1A658BEE0B7}" />

</listeners>

Now you can simply use it by calling Logger.Write(message) o or any other logging call. You can also add this listener to any category you want and optionally use formatters as well.

Remember that you can activate your event provider by opening and "Admin" command prompt and running:

logman create trace myApplication -p {D2FAAB3F-5D61-42B5-A014-D1A658BEE0B7} -o .\etwtrace.etl -ow
logman start myApplication

You can check that your data collector set is up and running by inspecting with Performance Monitor (perfmon.msc) and look into "Data Collector Sets\User Defined). There you may check for many properties of your process and also verify the etl file location which by default is in Windows\System32 folder with a file name like "etwtrace_000001.etl".

After you are done with the tracing, simply end by typing:

logman stop aExpense
logman delete aExpense

The information saved to the .etl file may be consumed by different tools described below and we can also use the tracerpt to generate an xml file and inspect the traced data or analyzing with WPA (Windows Performance Analyzer).

WSSF 2010 Open Source for Visual Studio 2012

2012-09-19T14:18:00Z

I just ported the Web Service Software Factory Modeling Edition (2010 Open Source) version to VS2012 RTM.

Notice that this is only the source code that builds and run from VS2012 (Windows 7 and Windows 8) but there's not refactoring or leverage of the new features in NET v4.5.

You can download it from here. Don't forget to read the Know issues in the download page.

CQRS Final version shipped

2012-07-27T16:39:00Z

The final version of the CQRS project is finally out!

After many optimizations added to the RI the final code and book is finally public here.

Some further rich insight details can also be found at Grigori's blog.

Enjoy it!

Acceptance Tests & Specflow

2012-05-15T02:32:00Z

An interesting post from the CQRS project was posted about the use of Specflow and the project Acceptance tests.

Here you will find the captured experience for creating the tests scenarios and the two approaches used for implementing the specs written with Specflow.

I will add further details on this experience in a future post while we get closer to the final version of the project.

Stay tunned!

CQRS Journey V1 is live

2012-05-09T17:25:00Z

For the last two month I've been working with the CQRS Journey team helping with the spec definitions and acceptance tests using Specflow which was a very interesting experience.

As you can see, this is basically a project from the Patterns & Practices group that shows an experience about an implementation of CQRS pattern into a reference implementation application.

You can find more fresh news and further details about this project in its blog.

In a future post I will highlight some of the experience and details of how we implemented the Acceptance Tests using Specflow within this project.

Stay tuned!

Web Service Software Factory 2010 Open Source CTP

2011-10-26T11:01:00Z

As a follow up of the WSSF Modeling Edition there is a new "flavor" of this tool where the main news is the versioning plan. The basic idea is to release the source code to the comunity in an "open source" model so any user may be free to update and add new features.

As part of this move, there are some additions and fixes that you will get in this open source release (CTP as the time of this post).

GAX free (no more dependency with GAX)
WCF Security Code Analysis added from WSSF v2 and updated to FxCop version from VS2010
Bug fixes
No more WSSF solution template (the WSSF menu options will show up on any compliant project and will let add models and WCF/ASMX templates)
Translator recipe removed. Writing translators is up to the user or it might be added using MEF extensibility.

You can download it and get some other build steps from here.

Stay tuned for the "official announcement" in Don's blog.

WCF Data Services and Custom Authorization

2011-06-16T10:33:00Z

In the last post about Decoding Messages in WCF Data Services I showed a code sample about how to decode an incoming WCF Message in a Data Service. In this case I will show how we can use this decoded message inside a ServiceAuthorizationManager derived class to perform some authorization depending on the content (i.e. grant access to some entities according to the logged on user).

The following configuration set an authorization manager using Windows Authentication.

<system.serviceModel>

<endpoint contract="System.Data.Services.IRequestHandler"

binding="webHttpBinding"

bindingConfiguration="WebHttpWindowsAuth">

</service>

</services>

<serviceSecurityAudit serviceAuthorizationAuditLevel="Failure"

auditLogLocation="Application"

messageAuthenticationAuditLevel="Failure"/>

</behavior>

</serviceBehaviors>

<binding name="WebHttpWindowsAuth"

maxBufferSize="65536"

maxBufferPoolSize="2147483647"

maxReceivedMessageSize="2147483647"

transferMode="StreamedResponse">

<readerQuotas maxDepth="2147483647"

maxStringContentLength="2147483647"

maxArrayLength="2147483647"

maxBytesPerRead="2147483647"

maxNameTableCharCount="2147483647" />

</security>

</binding>

</webHttpBinding>

</bindings>

</system.serviceModel>

</configuration>

As you can see, we can also set the audit feature to let WCF log any security issue on the message. Regarding the binding, we set the required webHttpBinding to use the max settings for message size assuming that we may need to send large messages (beware of DOS attacks). We also set the security setting for using Windows authentication.

Now we can implement the “CheckAccess(OperationContext operationContext, ref Message message)” overload of our ServiceAuthorizationManager dervived class (MyServiceAuthorization in config above) and decode the message so we can so something usefull with its content.

public override bool CheckAccess(OperationContext operationContext, ref Message message)

{

if (IsGet())

return true;

if (!CanDecodeMessage(ref message))

return false;

if (IsUserAllowed())

return true;

return false;

}

As you can see, we want to allow read access so we bail out for GET verbs using the IsGet() function described below. After that, if we cannot decode the message we simply deny access. Otherwise we perform our custom authorization and we are done.

private static bool IsGet()

{

return RequestMethod().Equals("GET", StringComparison.OrdinalIgnoreCase);

}

private static bool IsDelete()

{

return RequestMethod().Equals("DELETE", StringComparison.OrdinalIgnoreCase);

}

private static string RequestMethod()

{

object propertyValue;

if (OperationContext.Current.IncomingMessageProperties.TryGetValue(HttpRequestMessageProperty.Name, out propertyValue))

{

HttpRequestMessageProperty rqMessageProperty = HttpRequestMessageProperty)propertyValue;

return rqMessageProperty.Method;

}

return string.Empty;

}

private static bool CanDecodeMessage(ref Message message)

{

string decodedMsg = DecodeMessage(ref message);

if (decodedMsg == null)

{

return IsDelete();

}

return IsMultipart(decodedMsg);

}

Notice that “DecodeMessage(ref message)” is described in a previous post.

Now an interesting section is how we detect is the incoming message is actually a multipart message which is typically used in SaveBatch operations.

Here we have the inspection of the multipart message and we can also extract a specific entity and check for access. Notice that we use the Atom10ItemFormatter class along with some other syndication classes to make it easier the parsing operation which is a simplification of the object materialization mechanism used by Data Services.

private static bool IsMultipart(string decodedMsg)

{

bool isMultipart = false;

foreach (Match m in xmlContentFromMime.Matches(decodedMsg))

{

isMultipart |= HaveEntity(m.Value);

}

if (false == isMultipart)

{

isMultipart |= deleteContentFromMime.Matches(decodedMsg).OfType<Match>().

Where(m => m.Value != DataServicesMetadataNamespace).Count() > 0;

}

return isMultipart;

}

private static bool HaveEntity(string rawData)

{

Atom10ItemFormatter atomFormatter;

if(XmlUtility.TryParse<Atom10ItemFormatter>(rawData, out atomFormatter))

{

ThrowOnSensitiveEntity(atomFormatter);

XmlSyndicationContent content = atomFormatter.Item.Content as XmlSyndicationContent;

return (content != null);

}

return false;

}

private static void ThrowOnSensitiveEntity (Atom10ItemFormatter atomFormatter)

{

if (atomFormatter.Item.Categories.

FirstOrDefault(c => c.Name.Equals(typeof(MySensitiveEntity).FullName, StringComparison.OrdinalIgnoreCase)) != null)

{

throw new SecurityException(Properties.Resources.AccessDenied);

}

We use a couple of regular expressions to parse the xml sections in the multipart and also to detect when we have a DELETE section.

private const string DataServicesMetadataNamespace = "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata";

private static Regex xmlContentFromMime = new Regex(@"<\?xml[^>]+>\s*<\s*(\w+).*?<\s*/\s*\1>", RegexOptions.Singleline | RegexOptions.Compiled);

private static Regex deleteContentFromMime = new Regex("http://([\\w+?\\.\\w+])+([a-zA-Z0-9\\~\\!\\@\\#\\$\\%\\^\\&\\*\$\$_\\-\\=\\+\\\\\\/\\?\\.\\:\\;\\'\\,]*)?", RegexOptions.Singleline | RegexOptions.Compiled);

Finally after decoding the message, we can perform our validation. For that, we can use the result of the message decoding and parsing with the auxiliary classes shown above and also do some mapping with the incoming user identity.

Here is a sample of how we can get the incoming identity and perform some authorization with a pre-configured group or groups (AuthorizedGroup) that we can read from configuration or some external repository.

private bool IsUserAllowed ()

{

var groups = GetWindowsGroups();

return groups.Contains(AuthorizedGroup, StringComparer.OrdinalIgnoreCase);

}

private static IEnumerable<string> GetWindowsGroups()

{

OperationContext operationContext = OperationContext.Current;

return operationContext == null ? new List<string>() : GetWindowsGroups(operationContext.ServiceSecurityContext.WindowsIdentity);

}

private static IEnumerable<string> GetWindowsGroups(WindowsIdentity identity)

{

return identity.Groups != null ? identity.Groups.Translate(typeof(NTAccount)).

Select<IdentityReference, string>(i => i.Value) : new string[0];

}

An interesting part of this implementation is that it can be completely decoupled from the actual service implementation so we can very easily switch between different authorization strategies with a simple config change.

Decoding messages in WCF Data Services

2011-06-15T16:33:00Z

Recently I had to solve an interesting problem while working with WCF Data Services and how to decode an incoming WCF message so I can do something useful with its content.

Let’s say that you have an already configured Data Service and you intercept the message using some sort extension/interceptors in WCF.

Here is an example of such function:

private static string DecodeMessage(ref Message message)

{

if (message.IsEmpty)

return null;

using (MessageBuffer buffer = message.CreateBufferedCopy(Int32.MaxValue))

{

Message copy = buffer.CreateMessage();

using (MemoryStream ms = new MemoryStream())

{

copy.Properties.Encoder.WriteMessage(copy, ms);

ms.Flush();

message = buffer.CreateMessage();

return Encoding.UTF8.GetString(ms.ToArray());

}

As you can notice, after some basic message validation, we create a copy of the message to avoid changing the state of the original message which is typically passed by reference. Then we write all the content to MemoryStream which is handy for read/write operations.

The key here is to use the encoder specified in the message properties which may be MTOM for this kind of streamed message but it might be different according to the configured binding. After writing all the message content to memory, we may read from memory and create a string so we can easily inspect the actual message. If we know that we will always deal with XML content, we can use an XmlReader or the like to manipulate the content without the string conversion which may pay a performance penalty on large messages.

In the above code, we return the content as string because we may get an XML or Text formatted message so we can process accordingly.

In the next post I will show how we can use this code for inspecting a message to perform a custom authorization with ServiceAuthorizationManager.

Stay tuned!

Channel 9 presentation with the Composite Services Guidance

2011-04-11T23:34:00Z

Take a look at this presentation if you want to get a good idea of what is this project directly from Dmitri, the "father" of the creature.

And new videos for Service Routing and Inventory Centralizartion patterns.

New Videos for Composite Services Guidance - CTP2

2011-03-31T10:27:00Z

You can get the latest videos for Composite Services Guidance CTP2 that show many features of this project.

Videos Download

Video 1: Repair and Resubmit

Video 2: Analytic Tracing

Video 3: Custom Probe Function

Video 4: Termination Notification

Video 5: Service Routing

Video 6: Inventory Centralizatioin

Video 7: Inventory Centralization Part 2 - Inventory Endpoint

Inventory Centralization Patterns with Composite Services CTP2

2011-03-16T11:59:00Z

Recently my friend and coworker Dmitri Ossipov started his blog with great posts about some of the details and many useful links to well know and documented SOA patterns that this CTP includes.

Check this out for details on how the CTP implements on of the most public patterns, the Inventory Centralization Patterns, in this case for Schema, Policy and Contracts.

Patterns & Practices: Composite Services CTP2 is Public

2011-03-09T12:20:00Z

Finally the last CTP and pre-release version for the Composite Services is out. There were quite a lot of changes since CTP1. We added many new samples and many enhancements to the repository (DB) which is now called Inventory in sync with SOA Patterns. Here is a brief list of the main changes according to the included documentations.

Changes and additions in this release

This CTP release contains reusable source code and samples to illustrate implementation for the following patterns and scenarios:

Repair and Resubmit – this pattern is implemented in ESB Toolkit 2.0 as part of Exception Management Framework (EMF). This code drop provides code sample how to implement this pattern for Windows AppFabric workflow service, using Exceptions Web Service and workflow activities to create fault message, which will be created in EMF database.

Analytic Tracing – this code drop contains reusable code and samples for implementing ETW tracing: event collector service and database that store collected events. This capability may be used for scenarios that need flexibility on how collected events are decoded and processed via extensibility points you can configure and implement: plugins and event decoders with leveraging ETW tracing capabilities provided by the event collector service.

Inventory Centralization – this code drop contains service catalog database, web services and samples to show how to implement Metadata Centralization, Schema Centralization and Policy Centralization patterns.

Service Virtualization – we included sample for implementing this pattern using WCF routing service( which is part of .NET framework) and service metadata centralization capabilities to define routing service metadata in service catalog.

Termination Notification – we included sample for implementing this pattern using sample WCF service and policy centralization capabilities provided by this CTP release.

You will also find many new videos that will be uploaded to the home page any time soon.

Stay tunned for new posts regarding implemetation details and advanced customizations for custom policy exporters/importers and monitoring.

UPDATE: Check further details on Dmitri's great blog here: Composite Services CTP2 Released and Applying Inventory Centralization Patterns with Composite Services CTP2