public class WebRole : RoleEntryPoint
{
    /// <summary>
    /// Entry point before starting the Role
    /// </summary>
    public override bool OnStart()
    {
        // Get the Role instance Diagnostics configuration. 
        var config = DiagnosticMonitor.GetDefaultInitialConfiguration();

        // Define interval for persisting the performance counter data to azure storage.
        config.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(5);
        // CPU Utilization Counter
        PerformanceCounterConfiguration cpuUtilizationCounter = 
                new PerformanceCounterConfiguration()
        {
            CounterSpecifier = @"\Processor(_Total)\% Processor Time",
            //define the sample internal for the specific performance counter
            SampleRate = TimeSpan.FromSeconds(1)
        };
        if (!config.PerformanceCounters.DataSources.Contains(cpuUtilizationCounter, 
                    new PerformanceCounterComparer()))
        {
            config.PerformanceCounters.DataSources.Add(cpuUtilizationCounter);
        }
        // Start diagnostic monitor with the new configuration.
        DiagnosticMonitor.Start
    ("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
        return base.OnStart();
    }

    /// <summary>
    /// Performance Counter Comparer
    /// </summary>
    private class PerformanceCounterComparer : 
        IEqualityComparer<PerformanceCounterConfiguration>
    {
        public bool Equals(PerformanceCounterConfiguration a, 
                PerformanceCounterConfiguration b)
        {
            //Check whether the compared objects reference the same data.
            if (Object.ReferenceEquals(a, b)) return true;
            //Check whether any of the compared objects is null.
            if (Object.ReferenceEquals(a, null) || Object.ReferenceEquals(b, null))
                return false;
            // Check if the counter specifier and the sampling rate are the same.
            return (a.CounterSpecifier == b.CounterSpecifier && 
                a.SampleRate == b.SampleRate);
        }
        public int GetHashCode(PerformanceCounterConfiguration counter)
        {
            //Check whether the object is null
            if (Object.ReferenceEquals(counter, null)) return 0;
            //Get hash code for the CounterSpecifier field if it is not null.
            int hashCounterSpecifier = counter.CounterSpecifier == 
                           null ? 0 : counter.CounterSpecifier.GetHashCode();
            //Calculate the hash code for the counter.
            return hashCounterSpecifier ^ counter.SampleRate.GetHashCode();
        }
    }
}

const string storageAccoutName = "Storage-Name-Here"; 
const string privateKey = "Storge-Private-Key-Here";
const string deploymentId = "Deployment-Id-Here";
var storageAccount = CloudStorageAccount.Parse(String.Format(
    "DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", 
    storageAccoutName, privateKey));

// Get the diagnostics manager for the entire storage account.
var diagnosticManager = storageAccount.CreateDeploymentDiagnosticManager(deploymentId);

// Get diagnostics manager for the specific role instance.
RoleInstanceDiagnosticManager roleDiagManager = 
  diagnosticManager.GetRoleInstanceDiagnosticManager("WebRole1", "WebRole1_IN_0");

//Modify current configuration
var currentConfiguariton = roleDiagManager.GetCurrentConfiguration();
currentConfiguariton.PerformanceCounters.ScheduledTransferPeriod = 
                        TimeSpan.FromMinutes(5);
currentConfiguariton.PerformanceCounters.DataSources.Add
            (new PerformanceCounterConfiguration()
{
    CounterSpecifier = @"\Processor(_Total)\% Processor Time",
    SampleRate = TimeSpan.FromSeconds(1)
});

//Commit the changes
roleDiagManager.SetCurrentConfiguration(currentConfiguariton);

/// <summary>
/// Query helper for retrieving data from the WADPerformanceCountersTable
/// </summary>
public class QueryExecuter
{
    /// <summary>
    /// Cloud storage account client
    /// </summary>
    private CloudStorageAccount accountStorage;
    /// <summary>
    /// Default Constructor - Use development storage emulator.
    /// </summary>
    public QueryExecuter()
    {
        accountStorage = CloudStorageAccount.DevelopmentStorageAccount;
    }
    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="accountName">Azure storage name</param>
    /// <param name="privateKey">Azure storage private key</param>
    public QueryExecuter(string accountName, string privateKey)
    {
        accountStorage = CloudStorageAccount.Parse(String.Format(
          "DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", account
    }
    /// <summary>
    /// Retrieve Performance counter data
    /// </summary>
    /// <param name="counterFullName">Counter specifier full name</param>
    /// <param name="deploymentid">Deployment id</param>
    /// <param name="roleName">Role name</param>
    /// <param name="roleInstanceName">Role instance name</param>
    /// <param name="startPeriod">Start sample date time</param>
    /// <param name="endPeriod">End sample date time</param>
    /// <returns></returns>
    public List<PerformanceData> QueryPerformanceCounter(string counterFullName, 
        string deploymentid, string roleName, 
        string roleInstanceName, DateTime startPeriod, DateTime endPeriod)
    {
        PerformanceDataContext context = new PerformanceDataContext(
          accountStorage.TableEndpoint.ToString(), accountStorage.Credentials);
        var data = context.PerfData;
        CloudTableQuery<PerformanceData> query = null;
        query = (from d in data
                 where d.PartitionKey.CompareTo("0" + startPeriod.Ticks) >= 0
                                        && d.PartitionKey.CompareTo
                    ("0" + endPeriod.Ticks) <= 0
                                         && d.CounterName == counterFullName
                                             && d.EventTickCount >= startPeriod.Ticks
                                                 && d.EventTickCount <= endPeriod.Ticks
                                                      && d.DeploymentId == deploymentid
                                                         && d.Role == roleName
                                                             && d.RoleInstance == 
                            roleInstanceName
                 select d).AsTableServiceQuery<PerformanceData>();
        List<PerformanceData> selectedData = new List<PerformanceData>();
        try
        {
            selectedData = query.Execute().ToList<PerformanceData>();
        }
        catch
        {
        }
        return selectedData;
    }
}