In our previous articles, Introduction to SQL Server 2012 and Windows Azure Overview, we made references to Microsoft’s SQL Azure service. In this article we will take a closer look at its main features in more detail.

SQL Azure is a relational database solution with the capability to support both Windows Azure and on-premise applications with minimum latency. It is considered a managed service and it’s offered by Microsoft to allow you to build applications without concerning yourself about the storage they’ll use. Being a cloud service, SQL Azure gives you all the benefits of the cloud including:

-          The hardware and software that support the SQL database are all managed by Microsoft

-          Patching and maintenance are also managed by Microsoft

-          High availability and fault tolerance are guaranteed by an SLA (Service-level agreement)

-          Per usage billing and the availability to scale up or down whenever you have the need

All these features contribute to SQL Azure’s eased management. The service-level agreement is backed up by powerful and extremely secure datacenters offering you maximum protection of your databases. SQL Azure is built entirely on top of SQL Server and offers most of SQL Server’s features, such as the Tabular Data Streams (TDSs) for connecting, databases with tables, views, stored procedures, indexes, etc. They are all managed using the standard T-SQL language. SQL Azure allows you to store up to 150 GB of information in your database. If you need more storage for a database, you will have to spread it out over multiple databases and use parallel queries

Keep in mind that SQL Azure is secure by default and you have to create firewall rules to enable access to the service. It uses port 1433 and it must be open for the client application as well. Any open connection, being inactive for 30 minutes or using excessive resources, is dropped.

Note also that the T-SQL statement USE can’t be used in SQL Azure. You are forced to identify the database of your choice in the connection string. If you don’t, you will be connected to the master database by default.

SQL Azure comes in two editions – Web, with maximum database capacity of 5 GB, and Business, with maximum database capacity of 150 GB. The pricing is either on a per-use basis or on a 6-month commitment. Here is a price list cited from Microsoft:

Be aware that every portion of a GB is a billed GB and the size is calculated on a daily basis taking into account the maximum capacity during that day. The bills you get, however, are monthly. Microsoft has recently changed the names for the Azure services in their billings. That’s why you will get a bill for SQL database, not SQL Azure. Here is a list of all the name changes on the Microsoft billing portal:

We already investigated the SQL Azure Data Sync service in our previous article, Introduction to SQL Server 2012. It eases your work with SQL Azure even more by simplifying the process of synchronization between your SQL Azure and on-premise SQL databases. It even gives you the ability to choose which exact columns you would like to sync. By using SQL Azure Data Sync you can eliminate the boundaries between your databases and easily move to and from the cloud whenever you need to.  You can also use it for replicating your data across different geographical locations to enhance the worldwide experience of your users.

Rest assured that Microsoft has implemented a lot of security measures to protect your data stored in the cloud, including SQL Authentication and IP filtering. SQL Azure doesn’t yet support Transparent Data Encryption (TDE). It uses only the Tabular Data Stream (TDS) connection protocol. You can implement another form of application encryption if required. However, the SQL Azure Data Sync service does encrypt all the connections between its components, such as between the on-premise database and the cloud.

SQL Azure also enjoys most of the security benefits related to all the Microsoft cloud solutions discussed previously in the article Windows Azure Overview Part 4: Security.

Arrays provide basic functionality for grouping types. Every language implements array syntax in its own way, although the following considerations apply regardless of language:

• Arrays have a static size. The size of the array remains fixed after initial allocation. If you need to extend the size of the array, you must create a new array of the required size and then copy the elements from the old array.
• Arrays support indexed access. To access an item in an array, you can use its index.
• Arrays support enumerator access. You can access items in the array by enumerating through the contents using the foreach construct (C#) or For Each (Visual Basic .NET).
• Memory is contiguous. The CLR arranges arrays in contiguous memory space, which provides fast item access.

This section summarizes performance guidelines to consider when using arrays:

• Prefer arrays to collections unless you need functionality.
• Use strongly typed arrays.
• Use jagged arrays instead of multidimensional arrays.

Prefer Arrays to Collections Unless You Need Functionality

Arrays are the fastest of all collections, so unless you need special functionality, such as dynamic extension of the collection, you should consider using arrays rather than collections. Arrays also avoid the boxing and unboxing overhead.

Use Strongly Typed Arrays

Use strongly typed arrays where possible, rather than using object arrays to store types. This avoids type conversion or boxing depending upon the type stored in the array. If you declare an array of objects and then proceed to add a value type such as an integer or float to the array, it involves the boxing overhead as shown in the following code sample.

Object[] array = new Object[10]

arr[0] = 2+3; //boxing occurs here

To avoid the boxing overhead declare a strongly typed int array, as follows:

int [] arrIn = new int [10];

arrIn[0] = 2+3;

Storing reference types, such as string or custom classes in the array of objects, involves the typecasting overhead. Therefore, use strongly typed arrays to store your reference types to, as shown in the following code sample.

string[10]  arrStr = new string[10];

arrStr[0] =  new string(“abc”);

Use Jagged Arrays Instead of Multidimensional Arrays

A jagged array is a single dimensional array of arrays. The elements of a jagged array can be of different dimensions and sizes. Use jagged arrays instead of multidimensional arrays to benefit from MSIL performance optimizations.

MSIL has specific instructions that target single dimensional zero-based arrays (SZArrays) and access to this type of array is optimized. In contrast, multidimensional arrays are accessed using the same generic code for all types, which results in boxing and unboxing for arrays of primitive types.

Let’s look at an example showing the declaration and use of jagged arrays.

string[][] Address = new string[2][];  // A jagged array of strings

Address[0] = new string[1];

Address[1] = new string[2];

Address[0][0] = “Address [0,1]“;

Address[1][0] = “Address [1,0]“;

Address[1][1] = “Address [1,1]“;

for (int i =0; i <=1; i++) {

      for (int j = 0; j < Address[i].Length; j ++)

            MessageBox.Show(Address[i][j]);

}

You can compare the efficiency of jagged versus multidimensional arrays by studying the MSIL code generated in each case. Notice how the following code that uses a multidimensional array results in a function call.

int [,] secondarr = new int[1, 2];

secondarr[0, 0] = 40;

The preceding code generates the following MSIL. Notice the function call.

IL_0029: ldc.i4.s   40

IL_002b: call instance void int32[0...,0...]::Set(int32,int32,int32)

The following code shows the MSIL generated for a jagged array. Note the MSIL stelem instruction which replaces the array element at a given index with the int32 value on the evaluation stack.

int [][] intarr = new int[1][];

intarr[0] = new int[2];

intarr[0][0] = 10;

The preceding code generates the following MSIL. Note the use of the stelem instruction.

IL_001c:  ldc.i4.s   10

IL_001e:  stelem.i4

Additional Considerations

When using arrays you should also consider the following:

• Sorting. If you retrieve data from a database, see if you can presort it by using an ORDER BY clause in your query. If you need to use the sorted results from the database for additional searching and sorting of the subset of results, you may require sorting the arrays. You should always measure to find out which approach works better for your scenario: sorting, using SQL queries, or sorting using arrays in the business layer.
• Avoid returning an Array from a property. Instead, consider using indexing properties.

EmployeeList l = FillList();

for (int i = 0; i < l.Length; i++) {

   if (l.All[i] == x){…}

}

In the preceding code, each time the property All is used, you might be creating and returning an array. If the calling code uses the property in a loop as shown in the preceding code, an array is created on each iteration of the loop.

In addition, if you return an array from a method, the resulting code is somewhat nonintuitive. A code example follows. In either case, document the details for your API.

// calling code:

if (l.GetAll()[i]== x) {…}

If you must return an array from a piece of code, consider returning a copy to prevent synchronization issues between clients.

• In the following code example, each call to the myObj property creates a copy of the array. As a result, a copy of the array will be created each time the code DoSomething(obj.myObj[i]) is executed.

for (int i = 0; i < obj.myObj.Count; i++)

      DoSomething(obj.myObj[i]);

In our next article, we’ll look at the optimizing working with Collections.

AJP vs HTTP Connectors

As you probably know, JBoss contains a built-in HTTP request processor to enable it to serve HTTP requests. In production environments however, the application server usually does not handle HTTP requests directly. This task falls on a dedicated web server – most often Apache. This division of labor allows Apache to serve static content (think large image files) and do the heavy-lifting for HTTPS, while letting your app server concentrate on what it does best – generating dynamic content and business logic processing. Apache and JBoss communicate via the AJP protocol – which involves a separate listener in JBoss (actually in JBoss Web – a version of Tomcat, which serves as a web container for JBoss). The AJP processor is very similar to the HTTP one – which is hardly surprising given how similar AJP and HTTP are.

Monitoring an AJP Connector with Monitis

As with other JMX-related metrics, it is very easy to set up a JMX monitor for AJP Connectors.

Step 1. Make sure the Monitis HTTP connector is deployed as described as described here

Step 2. Navigate to the JMX Monitor URL and log on with your Monitis credentials

Step 3. After entering an agent name, click on “Add Test” link from the navigation bar, enter the JMX parameters and click “Submit”. The agent will then connect to the JMX server. (By  default the JMX port in JBoss 6.x is 1090, the username and password are blank – I certainly hope you are not running with these defaults in production!)

Step 4. Select “jboss.web” from the drop-down and navigate to the GlobalRequestProcessor class:

jboss.web:type=GlobalRequestProcessor,name=ajp-127.0.0.1-8009

Step 5. Give the monitor a meaningful name, select appropriate interval (in minutes), select MBean attributes (all except modellerType) and click “Add Monitor”:

Your monitor should now be up an running. When you log on to your Monitis account, you should be able to find it and add it to your dashboard. After allowing some time for monitoring data to accumulate, you can graph the data:

The same steps could be followed to set up a monitor for an HTTP Request processor – it exposes the same metrics as the AJP processor, the only difference being the naming of the MBean.

In another installment we will look at per-application metrics provided by SessionManager MBean. Until then, happy monitoring!

1. The monitor should collect as much important information as possible that will allow to accurately evaluate the health state of an object.
2. The monitor should have little to no effect on the activity of the object.

Sure, these two principles work against each other in most of cases, but with Node.js they work together quite nicely because Node.js is based on event-driven technology and doesn’t use the traditional threads-driven approach. This technology allows to register many listeners for one event and process them in parallel almost independently. To avoid even a small effect on the production server, it was decided to separate the monitor into two parts – the first is the javascript module-plugin that listens to all server events and accumulates necessary information and the second is the Linux shell script that periodically runs the monitor-plugin by using the REST technique for collecting, processing, and sending information to the Monitis main server.

Normally, it is necessary to add couple lines in your existing Node.js server code to activate the monitor-plugin:

var monitor = require('monitor');// insert monitor module-plugin
....

var server = … // the definition of current Node.js server

….

monitor.Monitor(server); //add server to monitor

Now the monitor will begin collecting and measuring data. The monitor-plugin has an embedded simple HTTP server that sends accumulated data by request and should correspond (in current implementation) to the following pattern

http://127.0.0.1:10010/node_monitor?action=getdata&access_code=

where
10010 – the listen port of monitor-plugin (configurable)
‘node_monitor’ – the pathname keyword
‘action=getdata’ – command for getting collected data
‘access_code’ – the specially generated access code that changes for every session

Please notice that monitis-plugin server (in current implementation) listens the localhost only. This and usage of the security access code for every session gives enough security while monitoring. More detailed information can be found along with implemented code in the github repository.

Server monitoring metrics

There are a largely standard set of metrics which can be used to monitor the underlying health of any server.

* CPU Usage describes the level of utilisation of the system CPU(s) and is usually broken down into three states.
o IO Wait – indicates the proportion of CPU cycles spent waiting for IO (disk or network) events. If you experience large IO Wait proportions, it can indicate that your disks are causing a performance bottleneck.
o System – indicates the proportion of CPU cycles spent performing kernel-level processing. Generally you will find only a small proportion of your CPU cycles are spent on system tasks, Hence if you see spikes it could indicate a problem.
o User – indicates the proportion of CPU cycles spent performing user instigated processing. This is where you should see the bulk of your CPU cycles consumed; it includes activities such as web serving, application execution, and every other process not owned by the kernel.
o Idle – indicates the spare CPU capacity you have – all the cycles where the CPU is, quite literally, doing nothing.
* Load Average is a metric that indicates the level of load that a server is under at a given point in time. Usually evaluated as number of requests per second.
* RAM usage by server is broken down usually into the following parts.
o Free – the amount of unallocated RAM available. Linux systems tend to keep this as low as possible; and do not free up the system’s physical RAM until it is requested by another process.
o Inactive – RAM that is in-use for buffers and page caching, but hasn’t been used recently so will be reclaimed first for use by a running process.
o Active – RAM that has been used recently and will not be reclaimed unless we have insufficient Inactive RAM to claim from. In Linux systems this is generally the one to keep an eye on. Sudden, rapid increases signal a memory hungry process that will soon cause VM swapping to occur.
* The server uptime is a metric showing the elapsed time since the last reboot. Non-linear behavior of the server uptime line indicates that the server was rebooted somehow.
* Throughput – the amount of data traffic passing through the servers’ network interface is fundamentally important. It is usually broken down into inbound and outbound throughput and normally measured as average values for some period by kbit or kbyte per sec.
* Server Response time is defined as the duration from receiving a request to sending a response. Normally, it should not exceed reasonable timeout (usually this depends on the complexity of processing) but should be as little as possible. Usually, the average and peak response time is evaluated for some time period.
* The count of successfully processed requests is evaluated as the percentage of responses with 2xx status codes (success) to requests during observing time. This value should be as close as possible to 100%.

We have used part of these metrics and added some specific statistics that are important for our task (e.g. client platform, detailed info for response codes, etc.)

Test results

The results below were obtained on a Node.js server equipped with the monitor described above on a Debian6-x64. The server listens on HTTP (81) and HTTPS (443) ports and does not have a large load.

By double-clicking on a line you can view a specific part of the monitoring data.

The data can be shown in graphical view too.

In conclusion, the monitoring system has successfully tracked the metrics and found the Node.Js server to be in a good health state.

In our previous article, SQL Server 2008 Overview, we looked over the different features that the Microsoft SQL Server provides. In this article we will focus on the new and advanced features of the latest SQL Server release – SQL Server 2012. They include, but are not limited to, the new High Availability solution AlwaysOn, improved security, and the capability of syncing with the cloud.

AlwaysOn consists of two main components – AlwaysOn Availability Groups and AlwaysOn Failover Cluster Instances. Let’s first focus on the Availability Groups. An availability group is a combination of databases that are hosted on a primary server and up to four secondary servers. Each availability group member is capable of replying to clients’ requests in the event that the primary group member is unavailable. All the databases in an availability group fail over to another group member together. This functionality is built on top of the Windows Server Failover Clustering feature and requires its installation.

The high availability of the SQL server can be further enhanced by using Failover Cluster Instances (FCI). However, this approach requires shared storage. Shared storage is not required for the AlwaysOn Availability Groups. The servers in an availability group are required to have shared storage only if they are also acting as FCI. Be aware that AlwaysOn Availability groups automatically failover to a different replica when a problem with primary one is detected. This automatic failover is not supported in FCI, so you will have to set the availability group members acting as FCI to manual failover.

Another service Microsoft offers for high availability of your SQL databases is SQL Azure Data Sync. It allows you to easily sync your on-premise SQL Server 2012 with your SQL Azure’s data. That’s why SQL Server 2012 is considered a cloud-ready application. Furthermore, it gives you the ability to specify exactly which columns you want to be synchronized. It is a full implementation of a service and there is no need for you to write extra code for this synchronization to occur. You can use it within your Disaster Recovery plan so that you will have a complete copy of your on-premise database on a different physical location.

Let’s now focus on the new features that SQL Server 2012 brings to the main SQL features:

1)      Analysis Services

SQL Server 2012 offers a unified model for all the needs your organization may have. This is the BI Semantic Model. It has the benefits of the tabular and the multidimensional models and it includes: PowerPivot for Excel to meet end users’ needs; PowerPivot for SharePoint to meet teams’ needs; and Analysis Services to meet corporate’s needs. It offers you the choice between cached and passthrough storage mode and security on both row and cell level.

2)      Reporting Services

In SQL Server 2012 the Reporting Services are now a SharePoint’s shared service taking advantage of all the native SharePoint service’s capabilities. Another big improvement is the enhanced end user alerting functionality. In SQL Server 2012 users can be notified when data in a report of their interest change.  This is done through a new user-friendly interface. It’s worth mentioning that the Reporting Services in SQL Server 2012 now support the 2007 and 2010 versions of Word and Excel.

3)      Integration Services

One of the new characteristics of Integration Services is the new Project model for deployment. The traditional Package model is still supported. However, with the Project model you can take advantage of some advanced features, such as:  eased centralized management of parameters and connection managers; and enhanced security, since the projects can be automatically encrypted and access to them easily controlled. Amongst the enhancements in SQL Server 2012 Integration Services is also the support of Visual Studio for Applications 3.0 and .NET 4.0.

You can use all of these new features with SQL Server 2012. The editions basically remain the same as with SQL Server 2008 with the addition of SQL Server 2012 Business Intelligence. This is a customized version of SQL Server that provides a platform for building and deploying business intelligence solutions in the most secure and scalable way. All the supported features that an SQL Server 2012 edition offers can be found and compared here: http://technet.microsoft.com/library/cc645993(SQL.110).aspx

To answer this question we need to take a closer look at the requirements for a server system to be considered cloud ready and then investigate the different features of Windows Server 2012 that does or does not meet these requirements. Windows Server 2012 is the official name of Windows Server code name “8” and is now on its Beta stage of development.

The first thing to consider here is the ability of the operating system to virtualize its resources, meaning to make them available as part of a shared pool and managed by an administrator. The main features Windows Server 2012 has here are:

-          Hyper-V extensible switch – the Hyper-V switch from Windows Server 2008 is now enhanced to support extensions. It is a platform for you to extend the functionality of a virtual switch to whatever your organization needs.

-          Network Virtualization – allows you to continue using you IP address scheme in the cloud infrastructure. All your virtual machines will have two IP addresses – one that you’re used to, and one new, that will be unique from the cloud perspective. All your services that depend on the IP address scheme will continue to work in the cloud.

-          Quality of Service (QoS) – gives you the opportunity to manage your network environment, identify problems, and prioritize traffic. You can use it to give priority to network-intensive applications such as voice traffic and to management messages indicating network connectivity problems.

-          Enhanced Live Storage Migration – allows you to move the files of a virtual machine while it’s still running. If a physical volume hosting VMs is running out of space, you don’t have to worry about moving one of all of the VMs to another location. Windows Server 2012 will do this job transparently without even turning the machines off.

Self-service is another thing you have to consider if you intend to provide or consume public cloud services. This functionality gives the clients the ability to change only the settings that are relevant to what they’ve paid for. It usually happens via custom Web page serving as a portal. Windows Server 2012 gives you the necessary foundation for this to happen by PowerShell and WMI.  Furthermore, Windows Server 2012 gives you the ability to monitor or to allow the customer to monitor the resources they’re using.

The next thing in our list would be elasticity. What it covers is the ability of the infrastructure to support the ever changing needs of the company using cloud services. If you host an application in the cloud, you would normally want more resources in peak user activity periods and less for the rest of the time. Furthermore, you may want to move your application from one geo-location to another. Windows Server 2012 has integrated support of IKEv2 VPN that can be used for hybrid cloud environments with interconnected public and private cloud infrastructures. IKEv2 VPN is an IPSec secured VPN connection allowing mobility of the connected users between different wireless access points or when moving from wireless to wired connection. The Network Virtualization functionality discussed earlier also helps Windows Server 2012 meet the elasticity requirements of today’s cloud infrastructures.

With all the Windows Server 2012 features mentioned we can definitely consider Windows Server 2012 a cloud ready operating system.

Keep eye on this block for further articles discussing Windows Server 2012’s advanced features!

The .NET Framework provides the System.String data type to represent a string. Intensive string manipulation can degrade performance. Every time you perform an operation to change string data, the original string in memory is discarded for later garbage collection and a new one is created to hold the new string data. Also note that the String type is a reference type, so the contents of the string are stored on the managed heap. As a result, strings must be garbage collected to be cleaned up.

This section summarizes recommendations you should consider when working with strings.

Avoid Inefficient String Concatenation

Excessive string concatenation results in many allocation and deallocation operations, because each time you perform an operation to change the string, a new one is created and the old one is subsequently collected by the garbage collector.

·         If you concatenate string literals, the compiler concatenates them at compile time.

//’Hello’ and ‘world’ are string literals

String str = “Hello” + “world”;

·         If you concatenate nonliteral strings, CLR concatenates them at run time. So using the + operator creates multiple strings objects in the managed heap.

·         Use StringBuilder for complex string manipulations and when you need to concatenate strings multiple times.

// using String and ‘+’ to append

String str = “Some Text”;

for ( … loop several times to build the string …) {

  str = str + ” additional text “;

}

// using String and .Append method to append

StringBuilder strBuilder = new StringBuilder(“Some Text “);

for ( … loop several times to build the string …) {

  strBuilder.Append(” additional text “);

}

Use + When the Number of Appends Is Known

If you know the number of appends to be made and you are concatenating the strings in one shot, prefer the + operator for concatenation.

String str = str1+str2+str3;

If you concatenate the strings in a single expression, only one call to String.Concat needs to be made. It results in no temporary strings (for partial combinations of the strings to be concatenated).

Avoid should not be using + on strings inside a loop or for multiple iterations. Use StringBuilder instead.

Use StringBuilder When the Number of Appends Is Unknown

If you do not know the number of appends to be made, which might be the case when iterating through a loop or building dynamic SQL queries, use the StringBuilder class as shown in the following code sample.

for (int i=0; i< Results.Count; i++)

{

  StringBuilder.Append (Results[i]);

}

The StringBuilder class starts with a default initial capacity of 16. Strings less than the initial capacity are stored in the StringBuilder object. The initial capacity of the buffer can be set by using the following overloaded constructor.

public StringBuilder (int capacity);

You can continue to concatenate without additional allocations until you consume the preallocated buffer. As a result, using a StringBuilder object is often more efficient than using String objects for concatenation. If you concatenate further, the StringBuilder class creates a new buffer of the size equal to double the current capacity.

So if you start with a StringBuilder of size 16 and exceed the limit, the StringBuilder allocates a new buffer of size 32 and copies the old string to the new buffer. The old buffer is inaccessible and becomes eligible for garbage collection.

You should try to set the initial capacity of the StringBuilder to an optimum value to reduce the cost of new allocations. To determine the optimum value for your case, the best way is to track the memory consumption by using the CLR profiler. For more information about how to use CLR profiler, see “How To: Use CLR Profiler” in the “How To” section of this guide.

Treat StringBuilder as an Accumulator

You can treat StringBuilder as an accumulator or reusable buffer. This helps avoid the allocations of temporary strings during multiple append iterations. Some of the scenarios where this helps are as follows:

• Concatenating strings. You should always prefer the following approach to string concatenation when using StringBuilder.

StringBuilder sb;

sb.Append(str1);

sb.Append(str2);

Use the preceding code rather than the following.

sb.Append(str1+str2);

This is because you do not need to make the temporary str1+str2 to append str1 and then str2.

·         Concatenating the strings from various functions.

An example of this is shown in the following code sample.

StringBuilder sb;

sb.Append(f1());

sb.Append(f2());

sb.Append(f3());

The preceding code snippet results in temporary string allocations for the return values by the functions f1 (…), f2 (), f3 (). You can avoid these temporary allocations by using the following pattern.

void f1( sb,);

void f2( sb,);

void f3( sb,);

In this case, the StringBuilder instance is directly passed as an input parameter to the methods. sb.Append is directly called in the function body, which avoids the allocation of temporary strings.

Use the Overloaded Compare Method for Case-Insensitive String Comparisons

Carefully consider how you perform case-insensitive string comparisons. Avoid using ToLower as shown in the following code because you end up creating temporary string objects.

// Bad way for insensitive operations because ToLower creates temporary

strings

String str=”New York”;

String str2 = “New york”;

if (str.ToLower()==str2.ToLower())

  // do something

The more efficient way to perform case-insensitive string comparisons is to use the Compare method.

str.Compare(str,str2,false);

The String.Compare method uses the info in the CultureInfo.CompareInfo property to compare culture-sensitive strings.

Monitoring Active Directory is essential to ensure that directory data remains consistent and users have uninterrupted access to their account and domain resources they require access to.

Importance of Active Directory Monitoring

Active Directory monitoring can check for specific indicators to make sure that problems are resolved when they first arise. Doing so can prevent possible service outages. IT can improve customer satisfaction because customers never experience the consequences of potential problems. The system will also be able to better cope with server outages when they do occur.

Monitoring will also help reveal problems that can lead to slower response times when the users access servers. For example, monitoring could reveal issues with user logon and resource access response times. Optimizing logon times and fast access to resources will contribute to a better overall user experience.

When monitoring Active Directory, administrators can experience better schedule flexibility that makes it easier for them to prioritize workloads. You want to monitor Active Directory to make sure that all of the necessary services are running on each domain controller and that replication is working throughout the domain and each domain controller holds the same data.

Monitoring is also being used to make sure the domain controllers don’t experience excessive CPU usage and that Lightweight Directory Access Protocol (LDAP) queries return a result quickly. Making sure LDAP is responsive speeds up the process of accessing and maintaining directory information services, which will increase productivity and – again – create a better overall user experience.

We’ll list a few of the most common issues below that can be prevented by monitoring your Active Directory and taking the appropriate action when an issue is detected.

Replication Issues

Replication issues can cause Active Directory data to be inconsistent across domain controllers. Proper monitoring will detect replication issues and can prevent problems associated with such issues like lingering AD objects or re-animated objects. Lingering objects emerge when the domain controller does not replicate until after the tombstone lifetime. This problem takes time to correct, since an extensive diagnosis will be required.

If the SYSVOL shared folder fails to replicate correctly, Group Policy objects and security policies are not correctly applied to domain clients.

Account Issues

Sometimes Active Directory can experience logon failures, account lockouts and account creation failures.

Logon failures can results from a trust relationship failure or the inability to perform proper name resolution. Sometimes, the failure results from a mismatch between the password and the computer account. The result is an end-user feeling frustrated not being able to access the domain and its resources.

Account lockouts happen if the PDC emulator is not available or several domain controllers experience a replication failure between each other. Active Directory normally locks out an account to prevent login attempts from overwhelming the server. As a result, account administrators spend their time troubleshooting the issue and are busy trying to help users regain access to their accounts. This wastes time and creates frustration for the user.

Account creation issues occur when there are not enough relative IDs and the RID master is unavailable. The relative ID is a variable length number that serves as a part of an object’s security identifier. The RID master is responsible for allocating security RIDs.

Domain Controller Failure and Application Failure

If the hard drive that holds Ntds.dit runs out of space, the domain controller will fail. Applications can fail when queries against Active Directory – that the application depends on – do not return a response or an incorrect result is returned because of a replication issue.

How to Efficiently Monitor Microsoft Active Directory

Small organizations will likely only need to occasionally check domain controllers. For large enterprises, monitoring solutions must gather large amounts of data and generate easily understandable reports that can help administrators make decisions. The need for a good monitoring solution becomes increasingly more important as the size of the Active Directory increases. There are several monitoring solutions available that can help you establish a good monitoring environment.

Monitis offers the advantage that its solution is cloud-based and therefor doesn’t require a dedicated in-house monitoring system. Windows Monitoring Scripts that interact with Monitis and integrate metric results in the Monitis Dashboard fulfill an important role in monitoring Active Directory. The Active Directory monitoring script creates a custom dashboard Monitor that can be easily adapted to include the metrics you require for your organization. The scripts can be downloaded from here: https://github.com/monitisexchange/Windows-Monitoring-Scripts.

Using these scripts and actively start monitoring Active Directory will help you detect and prevent possible issues with user accounts, directory data and security policies that might lead to server or domain outages and resolve slow response times.

References:

http://technet.microsoft.com/en-us/library/cc961807.aspx

http://technet.microsoft.com/en-us/library/cc961984.aspx

http://www.windowsecurity.com/articles/implementing-troubleshooting-account-lockout.html

https://github.com/monitisexchange/Windows-Monitoring-Scripts

First, let’s make it clear what an endpoint is. In Microsoft’s world this term represents any client computer, server, or laptop in an organization. Forefront Endpoint Protection is a line-of-business application developed by Microsoft to provide defense against viruses, worms, and other threats.

Forefront Endpoint Protection (FEP) 2010 was closely tied to System Center Configuration Manager (SCCM) through the infrastructure. This was beneficial for organizations which had already adopted SCCM, but was a challenge for ones without it implemented.

In their latest release, the Endpoint protection is actually part of the System Center family and takes the name System Center Endpoint Protection (SCEP) 2012. The integration of SCEP with SCCM allows you to centrally manage your endpoints. You can scan them for both updates and viruses. You can also schedule your scans so that they happen automatically.

In a typical scenario you would use one software solution for managing the updates of your endpoints, such as Windows Software Update Services (WSUS), and another solution for antivirus protection, such as McAfee. This means you have to open one management tool for WSUS and another one for McAfee.

By using a single dashboard, you can easily notice potential problems with your endpoints such as missing updates and potential viruses. This central management can save your IT staff significant time. The idea is that you should not look at the anti-virus protection as a separate solution. With Endpoint Protection, anti-virus protection is integrated into your whole IT management solution. Furthermore, SCEP ensures your Windows Firewall is also up and running, and any set policies take effect.

The SCEP client is very lightweight and any competitive antivirus solutions are automatically removed before installation. This can ease your adoption of SCEP when you have another solution in place.

A SCEP client is installed on all the endpoints, and it is automatically updated with definitions of known and unknown threats. The methods SCEP uses include:

- Behavior monitoring – allows the agent installed on the system to monitor the registry, the active processes and the system operations in order to identify any suspicious activities. If an activity is considered suspicious, then it is sent to Microsoft for investigating. If malware is detected, a signature is released.

- Dynamic Signature Service – keeps a dynamically updated list of all known signatures of attacks. With this feature the agent installed on the endpoint is able to get real-time information about whether an activity is considered malicious or not. If it is considered to be malicious, then corrective actions are applied, like quarantine or removal.

- Dynamic translation – is used by the agent to run code in a virtual environment and investigate it, before allowing it to run on the actual endpoint with the real resources. It can be used with code like ActiveX and JavaScript that run in the browser.

And the good news – Microsoft provides an absolutely free product, Microsoft Security Essentials, which can be used by end clients and uses the same core as the Forefront Endpoint Protection.

Avoid Repetitive Field or Property Access

If your data is static for the duration of the loop, obtain it before the loop instead of repeatedly accessing a field or property. The following code shows a collection of orders being processed for a single customer.

for ( int item = 0; item < Customer.Orders.Count ; item++ ){

  CalculateTax ( Customer.State, Customer.Zip, Customer.Orders[item] );

}

Note that State and Zip are constant for the loop and could be stored in local variables rather than accessed for each pass through the loop as shown in the following code.

string state = Customer.State;

string zip = Customer.Zip;

int count = Customers.Orders.Count;

for ( int item = 0; item < count ; item++ )

{

  CalculateTax (state, zip, Customer.Orders[item] );

}

Note that if these are fields, it may be possible for the compiler to do this optimization automatically. If they are properties, it is much less likely. If the properties are virtual, it cannot be done automatically.

Optimize or Avoid Expensive Operations Within Loops

Identify operations in your loop code that can be optimized. Look for code that causes boxing or allocations as a side effect. The following code causes side effect strings to be created for each pass through the loop.

String str;

Array arrOfStrings = GetStrings();

for(int i=0; i<10; i++)

{

  str+= arrOfStrings[i];

}

The following code avoids extra string allocations on the heap by using StringBuilder.

StringBuilder sb = new StringBuilder();

Array arrOfStrings = GetStrings();

for(int i=0; i<10; i++)

{

  sb.Append(arrOfStrings.GetValue(i));

}

The following tips can help avoid expensive loop operations:

·         Be aware of the method calls you make inside loops. Watch out for inadvertent method calls and consider using inline code where appropriate.

·         Consider StringBuilder for string concatenation inside a loop. For more information, see “String Operations” later in this chapter.

·         When testing for multiple conditions to exit out or continue looping, order your tests so that the one most likely to let you escape the loop, is run first.

Copy Frequently Called Code into the Loop

If you repeatedly call methods from inside a loop, consider changing the loop to reduce the number of calls made. The JIT compiler usually inlines any called code if it is simple, but in most complex scenarios it is your responsibility to optimize the code. The costs of the call increase as you cross process or computer boundaries with remoting or Web services. The following code shows a method being called repeatedly inside a loop.

for ( int item = 0 ; item < Circles.Items.Length; item++ ){

  CalculateAndDisplayArea(Circles[item]);

}

Consider the following strategies to reduce the calls incurred:

• Move the called code into the loop. This reduces the number of calls being made.
• Move the whole unit of work to the called object. The following code modifies the object being called and passes all the required data so that the whole loop can happen remotely. This is helpful to avoid round trips and offloads the work to local calls for an object which may be hosted remotely.

// call function to store all items

OrderProcessing op = new OrderProcessing();

StoreAllOrderItems (Order.Items);

…

class OrderProcessing{

…

  public bool StoreAllOrderItems ( Items itemsToInsert )

  {

    SqlConnection conn = new SqlConnection(…

    SqlCommnd cmd = new SqlCommand(…

    for ( int item = 0 ; item < orders.Items.Length; item++ ){

      // insert order into database

      // set parameters on command object

      cmd.ExecuteNonQuery();

      // insert order item

    }

  }

  . . .

}

Consider Replacing Recursion with Looping

Each recursive call adds data to the stack. Examine your code and see if your recursive calls can be converted to a looping equivalent. The following code makes recursive calls to accomplish a small task of string concatenation.

Array arr = GetArrayOfStrings();

int index = arr.Length-1;

String finalStr= RecurStr(index);

string RecurStr(int ind){

  if (ind<=0)

    return “”;

  else

    return (arr.GetValue(ind)+RecurStr(ind-1));

}

Rewritten, the following code now avoids creating new data on the stack for each successive call and avoids an additional method call to itself.

string ConcString (Array array)

{

  StringBuilder sb = new StringBuilder();

  for (int i= array.Length; i>0; i–)

  {

    sb.Append(array.GetValue(i));

  }

  return sb;

}

Use for Instead of foreach in Performance-Critical Code Paths

Use for instead of foreach (C#) to iterate the contents of collections in performance-critical code. foreach in C# and For Each in Visual Basic .NET use an enumerator to provide enhanced navigation through arrays and collections.