Now let’s get into to business quick and start off with a question : “How often did you want to reproduce / debug a certain process without actually knowing where the source of the problem may reside?”

Well the answer to that question for most of us will be : “Quite a lot” and then this would be followed immediately with the question : “Did you then create data log tables to store values, stack traces, information messages, …?” And again the answer will be often : “Yes”

Now this will probably help you out : ETW!

I will not go into the full details of Event Tracing for Windows as this would definately take us too far, but here’s a link where you can do some additional reading : http://msdn.microsoft.com/en-us/library/windows/desktop/bb968803(v=vs.85).aspx

What we will look at for this post is how we can make advantage of ETW to do some tracing within Dynamics Ax 2012. Specifically we are going to make a custom piece of code do output some informational messages that can be caught by a data collector set using Perfmon and viewed by the Event viewer.

The following question may arise : “Why would we want ETW to handle the tracing and not stay in our habitat of X++ and storing data in tables?” Well the answer to this is:

• ETW by far does not cause as many overhead as normal logging would do. Both for execution time (CPU) and diskspace.
• If your code is ETW ready, you can do logging in production environments by starting / stopping data collector sets.
• If your code is ETW ready, logging does not need to be built when needed but will immediately be available when needed.
• The log files can be used in Event Viewers and also SCOM so it helps system administrators to know what is going on in the black box Dynamics Ax.

So let us jump in and create the data collector set.

First start op by opening perfmon and navigate to the user defined data collector sets.

Right click and create a new data collector set.

After the creation of the data collector set, right click it and you can start / stop the collection of ETW events.

But now that we have the collection part, we also need to make custom code trigger some events from within Dynamics Ax. And that is where the xClassTrace  class comes into play. The xClassTrace class is used to make advantage of ETW and is used to start / stop traces to files, log component messages in ETW to be caught by data collector sets, …

So let us take a look at some sample code that loops all customers and logs a component message in ETW to be caught. (Please not the isTracingEnabled checks to make sure string formatting will only be done when needed to have the minimum amount of performance overhead)

static void KeSae_ETW_LogComponentMessageTest(Args _args)
{
    CustTable   theCustomer;
    ;
 
    if(xClassTrace::isTracingEnabled())
    {
        xClassTrace::logComponentMessage('AxTracing',"Starting ETW tracing");
    }
 
    while select theCustomer
    {
        if(xClassTrace::isTracingEnabled())
        {
            xClassTrace::logComponentMessage('AxTracing',strFmt("Processing customer %1", theCustomer.AccountNum));
        }
    }
 
    if(xClassTrace::isTracingEnabled())
    {
        xClassTrace::logComponentMessage('AxTracing',"Starting ETW tracing");
    }
}

Now that our code is ready to log some messages, start the data collector set in the perfmon tool and run the sample code. After running the code, go ahead and stop the data collector set. The result will be a log file generated that can be openened by the Event Viewer as seen below where we can actually see the logged messages from within Dynamics Ax.

So this is a very simple example, but this logging method is the way to go when you want efficient, performing logging in your system! This way you can minimize the logging overhead.

Some of you will be familiar enough with Ax 2009 and therefore know how to create multiple threads when running batch jobs.
For those of you who aren’t : no worries! Since most of it will be done in the same way as before, you will be up to speed in no time.

The main difference in Ax 2012 is the Business Operation Framework that renders the RunBaseBatch framework kinda obsolete. (Read : It’s MS best practice to use BOF instead of RunBaseBatch). The BOF lets you create services and run these services in CIL. I will spare you the full details about CIL as it out of the scope of this article. You can find all the details about creating these services in some very nice posts of a colleague of mine.

• Part 1 : Data contract and operations
• Part 2 : SysOperationServiceController
• Part 3 : SysOperationAutomaticsUiBuilder

Now that you have seen the basics, let’s get to the point of this article. Today we were wondering if the new BOF would also be able to handle multi-threaded batch processing and escpecially how it would be accomplished. Well here’s how…

In this example I will use a rather useless functionality but it’s done like this to keep things simple. I will have a set with some names in it and instead of running a service to display them all we will create two services :

• The KeSaeBatchService will be used to run the batch job with and devide the work into smaller threads
• The KeSaeRunTaskService will act as one of those threads running in batch

Creating the run task service

First thing to do is creating the KeSaeRunTaskService and creating a datacontract for it to contain a name it will be passed as a parameter. So start by creating the data contract.

[DataContractAttribute]
public class KeSaeRunTaskDataContract
{
    Name mName;
}
 
[DataMemberAttribute]
public Name parmName(Name _name = mName)
{
    ;
    mName = _name;
    return mName;
}

Now that we have the contract, let’s create the service class. The service class just contains one method ‘process‘ that will be passed a data contract.

class KeSaeRunTaskService
{
}
 
[SysEntryPointAttribute]
public void process(KeSaeRunTaskDataContract _theContract)
{
    ;
    // Inside the runTimeTask we just print the name passed
    info(strFmt('%1', _theContract.parmName()));
}

Now create a service within the AOT and add the operation as seen below.

Creating the batch operation service

Now let’s do the same thing all over again, but for the service that will be submitted to the batch framework.
The only additional thing here is to create a menu item to that service to be able to run it.

And last but not least we need to put in some code in the batch service to create smaller runTimeTasks when processing in batch so let’s take a look at the process method.

[SysEntryPointAttribute]
public void process()
{
    Set             theNames = new Set(Types::String);
    SetEnumerator   theEnum;
    Name            theName;
    ;
 
    // Add some names to the set to process
    theNames.add('Kenny');
    theNames.add('Klaas');
    theNames.add('Kevin');
    theNames.add('Tom');
    theNames.add('Ronald');
 
    // Create the enumerator
    theEnum = theNames.getEnumerator();
 
    // Loop all the names
    while (theEnum.moveNext())
    {
        // Get the next name
        theName = theEnum.current();
 
        // Create a service controller to run the task for processing one name
        mController = new SysOperationServiceController(classStr(KeSaeRunTaskService), methodStr(KeSaeRunTaskService, process));
 
        // Fetch the data contract from within the controller
        mContract = mController.getDataContractObject('_theContract');
 
        // Put the current name in the controller's data contract
        mContract.parmName(theName);
 
        // Check if we are batch processing or not
        if(this.isExecutingInBatch())
        {
            if(!mBatchHeader)
            {
                mBatchHeader = BatchHeader::getCurrentBatchHeader();
            }
 
            // Create a runTimeTask within the current batch job
            mBatchHeader.addRuntimeTask(mController, this.getCurrentBatchTask().RecId);
        }
        else
        {
            // Just run it immediately
            mController.run();
        }
    }
 
    // If we're processing in batch, then save the batch header
    if(mBatchHeader)
    {
        mBatchHeader.save();
    }
}

This piece of code differs from Ax 2009 by constructing a SysOperationServiceController instead of a RunBaseBatch class to add as a runTimeTask. This works because the SysOperationServiceController extends the SysOperationController which in it’s turn implements Batchable.

class SysOperationServiceController extends SysOperationController
public abstract class SysOperationController extends Object implements Batchable

That’s about it! Do not forget to compile CIL! Then you should be seeing this when your service is being processed in batch.

And when clicking the parameters button on one of the threads, you can see the name that was passed in the data contract to the thread.

All this can be found in an XPO file available here.

Since the arrival of Dynamics Ax 2012, the traditional RunBaseBatch framework is getting obsolete. This has been replaced by the SysOperationFramework. This framework brings a few nice features that were missing in the RunBaseBatch framework. One them is the MVC pattern to separate concerns.

The basics

I would like to start with a few links concerning how to create SysOperationFramework services. A colleague of mine, Klaas Deforce, has created some posts that clearly explain how it works.

All of the post are linked through this overview post : http://www.artofcreation.be/2011/08/21/ax2012-sysoperation-introduction/

Field display order

Well now, let’s come to the question of this post : How can you determine the sequence of dialog fields on the dialogs created by the SysOperationFramework? The answer here lies in the Attributes available also in Dynamics Ax 2012. You have a contract with several datamembers marked with the [DataMemberAttribute] attribute. To determine the sequence you can add the [SysOperationDisplayOrderAttribute] attribute (http://msdn.microsoft.com/en-us/library/gg963068.aspx).

For an example of this, you can check the AssetBalanceReportColumnsContract class, method parmAssetBookId.

[
    DataMemberAttribute('AssetBookId'),
    SysOperationGroupMemberAttribute('Book'),
    SysOperationDisplayOrderAttribute('1')
]
public AssetBookMergeId parmAssetBookId(AssetBookMergeId _assetBookId = assetBookId)
{
    assetBookId = _assetBookId;
    return assetBookId;
}

Groups and group sequence

In the previous sample of code you can also see the SysOperationGroupMemberAttribute attribute. This is to determine which fields belong to a certain group on a dialog. And you can also use a custom sequence on groups by using the SysOperationGroupAttribute attribute as seen in the classDeclaration:

[
    DataContractAttribute,
    SysOperationGroupAttribute('Book', "@SYS95794", '1'),
    SysOperationGroupAttribute('Period', "@SYS40", '2')
]
public class AssetBalanceReportColumnsContract implements SysOperationValidatable
{
    boolean visibleFR;
    AssetBookMergeId assetBookId;
    ToDate closingDatePriorYear;
    ToDate closingDateThisYear;
}

So there you have it. If you want to rearrange things on the dialog, you can use the above method.

The windows event viewer can be a nice tool to check for messages dispatched by the system. You can save the logs in there, reopen them, different kinds of information is available so you can actually trace lots of things in there. But wouldn’t it be nice to also be able to log the messages thrown by Ax 2012 in the windows event log?

That way you do not lose user messages and they are nicely logged into the event viewer. It can also help to log messages received on a client that you cannot seem to reproduce, …

Well, it is possible and here is how to do it in a couple of steps:

• Add a windows event log and source to put our specific infolog messages in
• Edit the Ax32 config file to add an event log listener to the configuration

Create event log and source

So first things first, let’s create a windows event log by using the following powershell command

new-eventlog -logname "RealDolmen Ax Solutions" -source "Ax 2012 Infolog"

The result should be like in the figure below

Configure the listener

To add a listener, first open the ax32.exe.config file located in the clientbin directory. You should see a configuration similar to this:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<startup useLegacyV2RuntimeActivationPolicy="true">
<supportedRuntime version="v4.0.30319" />
<requiredRuntime version="v4.0.30319" safemode="true"/>
</startup>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<probing privatePath="EditorComponents"/>
</assemblyBinding>
</runtime>
</configuration>

Modify the configuration so that it looks like this: (It is absolutely important to keep the source name !! The initializeData must be filled with the source you created in the event log)

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.diagnostics>
<trace autoflush="true"/>
<sources>
<source name="Microsoft.Dynamics.Kernel.Client.DiagnosticLog-Infolog" switchValue="Information">
<listeners>
<!-- The initializeData contains the source that was linked to the created event log -->
<add name="EventLog"
type="System.Diagnostics.EventLogTraceListener"
initializeData="Ax 2012 Infolog"/>
</listeners>
</source>
</sources>
</system.diagnostics>
<startup useLegacyV2RuntimeActivationPolicy="true">
<supportedRuntime version="v4.0.30319" />
<requiredRuntime version="v4.0.30319" safemode="true"/>
</startup>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<probing privatePath="EditorComponents"/>
</assemblyBinding>
</runtime>
</configuration>

Now we are all set up and when firing up the client, any messages to the infolog should be redirected to the event log. So let’s send some error lines to the infolog.

Now check if the same messages appear in the infolog. Normally this is what it should look like:

So there you have it. The messages are nicely logged in the event viewer. As a last remark, you can also adjust the logging level by modifying the switchvalue of the source. Off will not log anything at all, verbose will fill your event log with everything.

Today I was reading a very interesting post about possible extensions to the editor in AX 2012 and I would very much like to share it.

Basically it explains that the editor is a hosted visual studio editor (that was already clear) and by knowing this, it is also possible to use the extensions that are available there to the editor inside Ax.
The post I read was dealing with the brace matching extension that is available to do automatic formatting of the braces.

You can read the full post here : http://dev.goshoom.net/en/2011/10/ax2012-editor-extensions/

I’ve recently read a post on the performance team blog and I found it interesting so I’m posting the link again here.

http://blogs.msdn.com/b/axperf/archive/2011/10/14/client-access-log-dynamics-ax-2012.aspx

The blog post explains how to track user activity within the system.

It’s been a while since I’ve posted, but here’s a small little post about what I think is a cool feature in Ax 2012!

In AX2009, when you have a table that has a relation to another table and you want to use it in code, you have to provide a method that performs a select on the other table and returned the related record. ( fe : SalesTable.SalesLine() ) Well this is something cool in AX2012. Here’s how you can do it now.

On the main table you have the relationship. There you can use a new property called CreateNavigationPropertyMethods and set it to Yes.

Once you have done this, there will be a method on you table that returns the related record.

Today I attended what I think was the most interesting session of the conference for me. (There will be one about AIF today but I think this will not as interesting as what I learned about performance)

Basically what they did can be devided in these categories :

• Scale up and scale out on AOSs and Clients
  
• Utilize more SQL features
  
• Application effeciency
  
• World class diagnosis tools
  

SysGlobalObjectCache

The first part was about caching. They added a global cache but this time the cache is also available across sessions.
The cache also get syncronised between the AOS instances, but there is a short delay on this, so you never really can trust that the cache is identically on the other AOS Instances.

As to when the objects in the cache are cleared, there are two main triggers for deleting an object from the cache:

• The limit of number of objects is reached (to be found in the SysGlobalConfiguration table on SQL Server
• The developer deletes / overwrites the object in the cache

TraceParser

Before the trace parser was a tool to be installed additionally to Ax but now it is part of the system. There are a few ways in which you can use the trace parser:

• By starting up the performance cockpit from the tools menu
• By using it to code by starting and stopping trace and specifying a file to log to.

So this time it is actually much more stable and reliable to use. Actually now it is so easy that each developer should develop with the trace parser next to him at all times to keep performance in mind from the beginning.

Data Access : Ad Hoc mode

When your X++ query is getting too big, then use Ad Hoc mode. Here you would actually only select the fields you need.
Also, set the dynamics property on the query fields to false and set OnlyFetchActive to true on the FormDataSource

By selecting only the things you need, the kernel will not join all the tables in the table hierarchy but also the inherited tables where you need fields from.

SQL TempTable

In the AOT, you can now set the TableType on a table object to one of the following :

• InMemory (The old in memory temp table)
• Regular (Non temporary table)
• TempDB (SQL Server tempDB table)

SysOperation

Here I can be brief (because the white paper about this is going to follow later on)

Basically the RunBase framework is now only there for backward compatibility! So now the new SysOperation framework will be used.
This is residing in the AOS also, but more on that when I have a clearer view on this.

So this is what I could capture from the session. Probably missed a lot of other stuff too but for that, we will have the video’s J

This articles will be brief, because I don’t have much time between the sessions J

Yesterdag was the first day of the Dynamics Technical conference and following sessions were attended by me:

• Programming model improvements Part 1 of 2
• Programming model improvements Part 2 of 2
• Developing in .NET managed code and X++ Enhancements
• Solving the element ID problem

Programming model improvements Part 1 of 2

From this session, I remember the following additional features:

• Table inheritance is added. So now you can have abstract tables which are then inherited by child tables.
  The unit of work pattern also comes into play here as there will be issues to address to manage transactions and code dealing with one ‘virtual record’ which may consist of multiple child tables. (Vehicle table with child tables bycicle, car, truck, …)
• Next to normal X++ temporary tables, there is now also support for temporary tables in SQL Server
• Date effective tables have been added. This means you can actualy filter records based on an ‘effective as of date’
• Eventing has been added so now you can actually subscribe methods to events on other classes. Also, this is implemented by drag and drop so it is actually user friendly to do this.
• The normal batch framework has been ‘adjusted / replaced’ with the SysOperation framework
• The tree of linked tables are then linked by RecId, but you can actually have a key with fields specified in a field group to be used in the design when showing on what the linked was based
• Tables have full text indes support now : This means they can be optimized for searches on text fields to look for certain words in the body.

Historical data pattern

This one is actually cool. Let’s say you have a historical table to contain a history of sales. Then you can set properties on the SalesTable datasource and the kernel will keep the history for you. So when you change values on the sales order for example, the kernel will create / update records in the historical data table.

Query ranges vs Query filters

When using joins (outer joins) the query ranges can produce incorrect outcomes. But now query filters are used to fix that. Instead of using the QueryRange object on the query, you can now also use QueryFilter objects and they are more optimized for SQL Server.

The other sessions will be describes in following posts as there is new session beginning right now J