.NET

Performance Benchmark with an Handy Class

Kazi Manzur Rashid — Thu, 21 Jun 2007 17:47:30 GMT

Instrumentation and Logging is an essential part of Software Development. Generally, most of the developer thinks instrumentation and logging is all about exception logging in a text file, which is not correct at all. Certainly, exception takes a major part in the instrumentation and logging. However, how many of us really bother the way the log data is written, do we really bother to import this data in a software to further analysis? In the following, I will present a handy class, which will automatically benchmark the instrumented method, so that we can do further analysis on the overall performance of our application.

PerformanceLog.cs:

   1:  using System;

   2:  using System.IO;

   3:  using System.Text;

   4:  using System.Reflection;

   5:  using System.Diagnostics;

   6:  using System.Globalization;

   7:  using System.Configuration;

8:

9:

  10:  public sealed class PerformanceLog : IDisposable

  11:  {

  12:      private static readonly bool _isPerformancelogEnabled = Convert.ToBoolean(ConfigurationManager.AppSettings["performanceLogEnabled"]);

  13:      private static readonly string _logFile = AppDomain.CurrentDomain.BaseDirectory + ConfigurationManager.AppSettings["performanceLogFile"];

  14:      private static readonly bool _includeParameters = Convert.ToBoolean(ConfigurationManager.AppSettings["performanceLogIncludeParameters"]);

15:

  16:      private Stopwatch _watch;

17:

  18:      public PerformanceLog()

  19:      {

  20:          if (_isPerformancelogEnabled)

  21:          {

  22:              _watch = new Stopwatch();

  23:              _watch.Start();

  24:          }

  25:      }

26:

  27:      public void Dispose()

  28:      {

  29:          if (_isPerformancelogEnabled)

  30:          {

  31:              _watch.Stop();

32:

  33:              DateTime end = DateTime.Now;

  34:              DateTime start = end.AddMilliseconds(-_watch.ElapsedMilliseconds);

  35:              string userName = System.Web.HttpContext.Current.User.Identity.Name;

  36:              string methodInfo = GetCallingMethodDetails(_includeParameters);

37:

  38:              using (FileStream fs = new FileStream(_logFile, FileMode.Append, FileAccess.Write, FileShare.None))

  39:              {

  40:                  using (StreamWriter sw = new StreamWriter(fs, Encoding.ASCII))

  41:                  {

  42:                      sw.Write(string.Format("\"{0}\",\"{1}\",\"{2}\",\"{3}\",\"{4}\"\n", userName, methodInfo, start, end, _watch.Elapsed));

  43:                  }

  44:              }

  45:          }

  46:      }

47:

  48:      private static string GetCallingMethodDetails(bool includeParameters)

  49:      {

  50:          StringBuilder output = new StringBuilder();

  51:          //Skipping two Frame, First one is the current method and second one is the dispose method.

  52:          StackTrace stackTrace = new StackTrace(2, false);

53:

  54:          StackFrame stackFrame = stackTrace.GetFrame(0);

  55:          MethodBase method = stackFrame.GetMethod();

56:

  57:          output.Append(method.Name);

  58:          output.Append("(");

59:

  60:          if (includeParameters)

  61:          {

  62:              ParameterInfo[] paramInfos = method.GetParameters();

63:

  64:              if ((paramInfos != null) && (paramInfos.Length > 0))

  65:              {

  66:                  output.Append(paramInfos[0].ParameterType.ToString());

  67:                  output.Append(" ");

  68:                  output.Append(paramInfos[0].Name);

69:

  70:                  if (paramInfos.Length > 1)

  71:                  {

  72:                      for (int j = 1; j < paramInfos.Length; j++)

  73:                      {

  74:                          output.AppendFormat(", {0} {1}", paramInfos[j].ParameterType.ToString(), paramInfos[j].Name);

  75:                      }

  76:                  }

  77:              }

  78:          }

79:

  80:          output.Append(")");

81:

  82:          return output.ToString();

  83:      }

  84:  }

Usage:

   1:      public List<Category> GetAllCategory()

   2:      {

   3:          using (PerformanceLog log = new PerformanceLog())

   4:          {

   5:              //Do your Processing over here

   6:          }

   7:      }

Web/App.config:

  <appSettings>
    <add key="performanceLogEnabled" value="true"/>
    <add key="performanceLogFile" value="PerformanceLog.csv"/>
    <add key="performanceLogIncludeParameters" value="false"/>
  </appSettings>

Logging Data:

"Amit-Dell\Kazi Manzur Rashid","GetAllCategory()","6/21/2007 11:26:06 PM","6/21/2007 11:26:08 PM","00:00:02.0282049"
"Amit-Dell\Kazi Manzur Rashid","GetProductList()","6/21/2007 11:26:08 PM","6/21/2007 11:26:09 PM","00:00:00.7225937"
"Amit-Dell\Kazi Manzur Rashid","GetProductList()","6/21/2007 11:26:12 PM","6/21/2007 11:26:12 PM","00:00:00.0400289"
"Amit-Dell\Kazi Manzur Rashid","GetProductList()","6/21/2007 11:26:43 PM","6/21/2007 11:26:43 PM","00:00:00.0012069"
"Amit-Dell\Kazi Manzur Rashid","GetProductList()","6/21/2007 11:26:43 PM","6/21/2007 11:26:44 PM","00:00:00.0463002"
"Amit-Dell\Kazi Manzur Rashid","GetCustomerList()","6/21/2007 11:26:49 PM","6/21/2007 11:26:49 PM","00:00:00.0952376"
"Amit-Dell\Kazi Manzur Rashid","GetAllSupplier()","6/21/2007 11:28:33 PM","6/21/2007 11:28:33 PM","00:00:00.0364298"

As you can see the class is simply dumping the User Name, The instrumented method(The Parameters info can be turned on from the web.config), start and end time of the method and the total elapsed time of the method in a csv format. The benefit of generating in csv format is we can easily import these data in Microsoft Excel to take full advantage of Excel such as finding the Longest and shortest call, Average call, Number of Average call of a User, Graph etc.

The simplicity of the class is, we do not have to do anything fancy except creating an instance of the class. The class is responsible to discover the method name and its parameter, start/end/elapsed time, user name etc.

In Pageflakes, we are doing the same but in a different twist, we are utilizing the Enterprise Library (logging and Instrumentation Block) to generate this. If you are interested to see how the EntLib can be used to do the above let me know.

Download: PerformanceLog.cs

Asp.net Ajax Grid and Pager Control

Kazi Manzur Rashid — Thu, 31 May 2007 09:15:35 GMT

My recent article "ASP.NET Ajax Grid and Pager" has been published in DotNetSlackers.com. A fully designer supported Ajax Control, which mimics the GridView Control in client side. Please vote for me if you find it useful.

Secure Cookie

Kazi Manzur Rashid — Thu, 18 Jan 2007 17:20:00 GMT

This my second post of almost same topic asp.net lacking. This time it is Cookie. Still Asp.net has the lacking of creating encrypted cookie. Here is another handy class which generates encrypted cookie.

Usage:

//Writing Cookie
SecureCookie.Set(Response, "Key1", "Value1", DateTime.Now.AddDays(1));
SecureCookie.Set(Response, "Key1", "Value1"); //Overloaded

//Reading Cookie
string key1Value = SecureCookie.Get(Request, "Key1");

SecureCookie:

using System;
using System.IO;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Diagnostics;
using System.Security.Cryptography;


public sealed class SecureCookie
{
    //Rijndael Key size is 256 bit or 32 byte, Can also be mentioned in web.config instead of hardcoding
    private static readonly byte[] Key = new byte[] {45, 236, 171, 7, 85, 6, 41, 34, 216, 14, 78, 156, 78, 3, 103, 154, 9, 150, 65, 54, 226, 95, 68, 79, 159, 36, 246, 57, 177, 107, 116, 8};

    [DebuggerStepThrough()]
    public static void Set(HttpResponse response,
    string key,
    string value,
    DateTime expire)
    {
        HttpCookie cookie = new HttpCookie(HttpUtility.UrlEncode(Encrypt(key)), HttpUtility.UrlEncode(Encrypt(value)));

        if ((expire != DateTime.MinValue) && (expire != DateTime.MaxValue))
        {
            cookie.Expires = expire;
        }

        response.Cookies.Set(cookie);
    }

    [DebuggerStepThrough()]
    public static void Set(HttpResponse response,
    string key,
    string value)
    {
        Set(response, key, value, DateTime.MaxValue);
    }

    [DebuggerStepThrough()]
    public static string Get(HttpRequest request, string key)
    {
        HttpCookie cookie = request.Cookies[HttpUtility.UrlEncode(Encrypt(key))];

        if (cookie == null)
        {
            return null;
        }

        if ((cookie.Value == null) || (cookie.Value.Length == 0))
        {
            return null;
        }

        string value = HttpUtility.UrlDecode(cookie.Value);

        return Decrypt(value);
    }

    [DebuggerStepThrough()]
    private static string Encrypt(string plain)
    {
        if ((plain == null) || (plain.Length == 0))
        {
            return null;
        }

        using(SymmetricAlgorithm crypto = CreateCrypto())
        {
            return System.Convert.ToBase64String(Read(crypto.CreateEncryptor(), Encoding.ASCII.GetBytes(plain)));
        }
    }

    [DebuggerStepThrough()]
    private static string Decrypt(string cipher)
    {
        if ((cipher == null) || (cipher.Length == 0))
        {
            return null;
        }

        using(SymmetricAlgorithm crypto = CreateCrypto())
        {
            return Encoding.ASCII.GetString(Read(crypto.CreateDecryptor(), System.Convert.FromBase64String(cipher)));
        }
    }

    [DebuggerStepThrough()]
    private static SymmetricAlgorithm CreateCrypto()
    {
        //Using Rijndael as it is much more secure among the others
        SymmetricAlgorithm crypto = new RijndaelManaged();

        crypto.Key = Key;
        crypto.IV = new byte[crypto.IV.Length];

        return crypto;
    }

    [DebuggerStepThrough()]
    private static byte[] Read(ICryptoTransform transformer,
    byte[] data)
    {
        using(MemoryStream ms = new MemoryStream())
        {
            using(CryptoStream cs = new CryptoStream(ms, transformer, CryptoStreamMode.Write))
            {
                cs.Write(data, 0, data.Length);
                cs.FlushFinalBlock();

                return  ms.ToArray();
            }
        }
    }
}

Secure Url

Kazi Manzur Rashid — Thu, 18 Jan 2007 11:17:00 GMT

Asp.net 2.0 has been released, but Asp.net still does not have any built-in support for passing querystring in encrypted text. The following class will give you the support to pass querystring in encrypted rather than plain.

Usage:

//WebForm1.aspx, From the sender
SecureUrl url = new SecureUrl("WebForm2.aspx?Key1=Value1&Key2=Value2");// WebForm2.aspx?param=HrxR96wU%2foN8VhElKlT32taPZLQzADf1
Response.Redirect(url.ToString());

//WebForm2.aspx, To Receiver
SecureUrl url = new SecureUrl(Request.Url.PathAndQuery);
string Key1Value = url["Key1"];
string Key2Value = url["Key2"];

SecureUrl:

using System;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Collections;
using System.Collections.Specialized;
using System.Security.Cryptography;
using System.Web;


public sealed class SecureUrl
{
    private const string ENCRYPTED_KEY_NAME = "param";
    private const string RETURN_URL = "returnUrl";
    private const string RETURN_PARAM = "returnParam";

    //DES Key size is 64 bit or 8 byte
    private static readonly byte[] Key = new byte[] {33, 93, 171, 1, 85, 23, 231, 145};

    private string _pageUrl = string.Empty;
    private StringDictionary _queryString = new StringDictionary();

    public string this[string key]
    {
        [DebuggerStepThrough()]
        get
        {
            if (_queryString.ContainsKey(key.ToLower()))
            {
                return _queryString[key];
            }

            return string.Empty;
        }
        [DebuggerStepThrough()]
        set
        {
            if ((value != null) && (value.Trim().Length > 0))
            {
                _queryString[key.ToLower()] = value;
            }
            else
            {
                _queryString.Remove(key.ToLower());
            }
        }
    }

    public string ReturnUrl
    {
        [DebuggerStepThrough()]
        get
        {
            if (_queryString.ContainsKey(RETURN_URL))
            {
                return _queryString[RETURN_URL];
            }

            return string.Empty;
        }
        [DebuggerStepThrough()]
        set
        {
            if ((value != null) && (value.Trim().Length > 0))
            {
                _queryString[RETURN_URL] = value;
            }
            else
            {
                _queryString.Remove(RETURN_URL);
            }
        }
    }

    public string ReturnParameters
    {
        [DebuggerStepThrough()]
        get
        {
            if (_queryString.ContainsKey(RETURN_PARAM))
            {
                return _queryString[RETURN_PARAM];
            }

            return string.Empty;
        }
        [DebuggerStepThrough()]
        set
        {
            if ((value != null) && (value.Trim().Length > 0))
            {
                _queryString[RETURN_PARAM] = value;
                
            }
            else
            {
                _queryString.Remove(RETURN_PARAM);
            }
        }
    }

    public SecureUrl(string fullUrl)
    {
        if (fullUrl.IndexOf('?') > 0)
        {
            string[] urlAndQueryString = fullUrl.Split('?');
            _pageUrl = urlAndQueryString[0];

            if (urlAndQueryString.Length > 1)
            {
                Parse(urlAndQueryString[1]);
            }
        }
        else
        {
            _pageUrl = fullUrl;
        }
    }

    public SecureUrl(string url, 
    string queryString)
    {
        _pageUrl = url;
        Parse(queryString);
    }

    [DebuggerStepThrough()]
    public void Clear()
    {
        _queryString.Clear();
    }

    [DebuggerStepThrough()]
    public bool Contains(string key)
    {
        return _queryString.ContainsKey(key.ToLower());
    }

    [DebuggerStepThrough()]
    public void Remove(string key)
    {
        _queryString.Remove(key);
    }

    [DebuggerStepThrough()]
    public override string ToString()
    {
        return ToString(false);
    }

    [DebuggerStepThrough()]
    public string ToString(bool unicode)
    {
        StringBuilder queryString = new StringBuilder();

        foreach(DictionaryEntry entry in _queryString)
        {
            queryString.Append(entry.Key.ToString().ToLower());
            queryString.Append('=');
            queryString.Append(HttpUtility.UrlEncode(entry.Value.ToString()));
            queryString.Append('&');
        }

        if (queryString.Length > 0)
        {
            //Remove the last &
            queryString.Remove(queryString.Length - 1, 1);
        }

        string encryptedQuery = Encrypt(queryString.ToString());

        string encodedQuery = HttpUtility.UrlEncode(encryptedQuery);

        if (unicode)
        {
            //Required if we are passing it to JavaScript
            encodedQuery = HttpUtility.UrlEncodeUnicode(encodedQuery);
        }

        string result = string.Empty;

        if (encodedQuery.Length > 0)
        {
            result = _pageUrl + "?" + ENCRYPTED_KEY_NAME + "=" + encodedQuery;
        }
        else
        {
            result = _pageUrl;
        }

        return result;
    }

    [DebuggerStepThrough()]
    private void Parse(string queryString)
    {
        string[] pairs = queryString.Split('&');

        if ((pairs != null) && (pairs.Length > 0))
        {
            for(int i = 0; i < pairs.Length; i++)
            {
                string[] pair = pairs[i].Split('=');
                string key = pair[0];
                string value = pair[1];

                value = HttpUtility.UrlDecode(value);

                if (string.Compare(key, ENCRYPTED_KEY_NAME, true) == 0)
                {
                    if (value.Length > 0)
                    {
                        string decryptedString = HttpUtility.UrlDecode(Decrypt(value));

                        string[] keyAndValues = decryptedString.Split('&');

                        if ((keyAndValues != null) && (keyAndValues.Length > 0))
                        {
                            for(int j = 0; j < keyAndValues.Length; j++)
                            {
                                string[] keyAndValue = keyAndValues[j].Split('=');

                                if ((keyAndValue != null) && (keyAndValue.Length == 2))
                                {
                                    _queryString.Add(keyAndValue[0].ToLower(), keyAndValue[1]);
                                }
                            }
                        }
                    }
                }
                else
                {
                    _queryString.Add(key.ToLower(), value);
                }
            }
        }
    }

    [DebuggerStepThrough()]
    private static string Encrypt(string plain)
    {
        if ((plain == null) || (plain.Length == 0))
        {
            return null;
        }

        using(SymmetricAlgorithm crypto = CreateCrypto())
        {
            return System.Convert.ToBase64String(Read(crypto.CreateEncryptor(), Encoding.ASCII.GetBytes(plain)));
        }
    }

    [DebuggerStepThrough()]
    private static string Decrypt(string cipher)
    {
        if ((cipher == null) || (cipher.Length == 0))
        {
            return null;
        }

        using(SymmetricAlgorithm crypto = CreateCrypto())
        {
            return Encoding.ASCII.GetString(Read(crypto.CreateDecryptor(), System.Convert.FromBase64String(cipher)));
        }
    }

    [DebuggerStepThrough()]
    private static SymmetricAlgorithm CreateCrypto()
    {
        //Using DES as it is the fastest among the others
        SymmetricAlgorithm crypto = new DESCryptoServiceProvider();

        crypto.Key = Key;
        crypto.IV = new byte[crypto.IV.Length];

        return crypto;
    }

    [DebuggerStepThrough()]
    private static byte[] Read(ICryptoTransform transformer,
    byte[] data)
    {
        using(MemoryStream ms = new MemoryStream())
        {
            using(CryptoStream cs = new CryptoStream(ms, transformer, CryptoStreamMode.Write))
            {
                cs.Write(data, 0, data.Length);
                cs.FlushFinalBlock();

                return  ms.ToArray();
            }
        }
    }
}

My First Article

Kazi Manzur Rashid — Sat, 13 Jan 2007 18:14:00 GMT

Recently I wrote an article "How to exchange data securely with a WebService without HTTPS/SSL" in codeproject. If Cryptography, Public/Private Key, Digital Signature and Web Service are one of your interest, I strongly recommend to read it.

Writing Code against the External Service

Kazi Manzur Rashid — Sat, 13 Jan 2007 17:18:00 GMT

When consuming any external service, don't expect the external service developer is as much smart as you are. Recently I have faced an issue when integrating with Amazon S3 that they failed to serve the data on first request, but on the consequent request they are able to return the data. So I did a little tweak in my code, instead of calling the service once, I am retrying up to 3 times. If the retry also fails the regular code block executes:

const int MAX_TRY = 3;
int tryCount = 1;
byte[] result = null;

using(AmazonS3 proxy = CreateServiceProxy())
{
    while(((result == null) || (result.Length == 0)) && (tryCount < MAX_TRY))
    {
        try
        {
            result = proxy.GetObject(_bucketName, key, false, true, true, _accessKeyID, timestamp, true, signature, null).Data;
        }
        catch
        {
            tryCount += 1;

            if (tryCount == MAX_TRY)
            {
                throw;
            }
        }
    }
}

return result;