diff --git a/src/corelib/Providers/Rackspace/CloudLoadBalancerProvider.cs b/src/corelib/Providers/Rackspace/CloudLoadBalancerProvider.cs
index be4a18221..865ebdf43 100644
--- a/src/corelib/Providers/Rackspace/CloudLoadBalancerProvider.cs
+++ b/src/corelib/Providers/Rackspace/CloudLoadBalancerProvider.cs
@@ -14,6 +14,7 @@
     using net.openstack.Providers.Rackspace.Objects.LoadBalancers.Request;
     using net.openstack.Providers.Rackspace.Objects.LoadBalancers.Response;
     using net.openstack.Providers.Rackspace.Validators;
+    using Newtonsoft.Json.Linq;
     using CancellationToken = System.Threading.CancellationToken;
     using JsonRestServices = JSIStudios.SimpleRESTServices.Client.Json.JsonRestServices;
 
@@ -945,25 +946,119 @@ public Task<IEnumerable<string>> ListAllowedDomainsAsync(CancellationToken cance
         /// <inheritdoc/>
         public Task<IEnumerable<LoadBalancer>> ListBillableLoadBalancersAsync(DateTimeOffset? startTime, DateTimeOffset? endTime, int? offset, int? limit, CancellationToken cancellationToken)
         {
-            throw new NotImplementedException();
+            if (endTime < startTime)
+                throw new ArgumentOutOfRangeException("endTime");
+            if (offset < 0)
+                throw new ArgumentOutOfRangeException("offset");
+            if (limit <= 0)
+                throw new ArgumentOutOfRangeException("limit");
+
+            UriTemplate template = new UriTemplate("/loadbalancers/billable?startTime={startTime}&endTime={endTime}&offset={offset}&limit={limit}");
+            var parameters = new Dictionary<string, string>();
+            if (startTime != null)
+                parameters.Add("startTime", startTime.Value.ToString("yyyy-MM-dd"));
+            if (endTime != null)
+                parameters.Add("endTime", endTime.Value.ToString("yyyy-MM-dd"));
+            if (offset != null)
+                parameters.Add("offset", offset.ToString());
+            if (limit != null)
+                parameters.Add("limit", limit.ToString());
+
+            Func<Task<Tuple<IdentityToken, Uri>>, HttpWebRequest> prepareRequest =
+                PrepareRequestAsyncFunc(HttpMethod.GET, template, parameters);
+
+            Func<Task<HttpWebRequest>, Task<ListLoadBalancersResponse>> requestResource =
+                GetResponseAsyncFunc<ListLoadBalancersResponse>(cancellationToken);
+
+            Func<Task<ListLoadBalancersResponse>, IEnumerable<LoadBalancer>> resultSelector =
+                task => (task.Result != null ? task.Result.LoadBalancers : null) ?? Enumerable.Empty<LoadBalancer>();
+
+            return AuthenticateServiceAsync(cancellationToken)
+                .ContinueWith(prepareRequest)
+                .ContinueWith(requestResource).Unwrap()
+                .ContinueWith(resultSelector);
         }
 
         /// <inheritdoc/>
         public Task<IEnumerable<LoadBalancerUsage>> ListAccountLevelUsageAsync(DateTimeOffset? startTime, DateTimeOffset? endTime, CancellationToken cancellationToken)
         {
-            throw new NotImplementedException();
+            if (endTime < startTime)
+                throw new ArgumentOutOfRangeException("endTime");
+
+            UriTemplate template = new UriTemplate("/loadbalancers/usage?startTime={startTime}&endTime={endTime}");
+            var parameters = new Dictionary<string, string>();
+            if (startTime != null)
+                parameters.Add("startTime", startTime.Value.ToString("yyyy-MM-dd"));
+            if (endTime != null)
+                parameters.Add("endTime", endTime.Value.ToString("yyyy-MM-dd"));
+
+            Func<Task<Tuple<IdentityToken, Uri>>, HttpWebRequest> prepareRequest =
+                PrepareRequestAsyncFunc(HttpMethod.GET, template, parameters);
+
+            Func<Task<HttpWebRequest>, Task<ListLoadBalancerUsageResponse>> requestResource =
+                GetResponseAsyncFunc<ListLoadBalancerUsageResponse>(cancellationToken);
+
+            Func<Task<ListLoadBalancerUsageResponse>, IEnumerable<LoadBalancerUsage>> resultSelector =
+                task => (task.Result != null ? task.Result.UsageRecords : null) ?? Enumerable.Empty<LoadBalancerUsage>();
+
+            return AuthenticateServiceAsync(cancellationToken)
+                .ContinueWith(prepareRequest)
+                .ContinueWith(requestResource).Unwrap()
+                .ContinueWith(resultSelector);
         }
 
         /// <inheritdoc/>
-        public Task<IEnumerable<LoadBalancerUsage>> ListHistoricalUsageAsync(LoadBalancerId loadBalancerId, DateTimeOffset? startTime, DateTimeOffset? endTime, CancellationToken cancellationToken1)
+        public Task<IEnumerable<LoadBalancerUsage>> ListHistoricalUsageAsync(LoadBalancerId loadBalancerId, DateTimeOffset? startTime, DateTimeOffset? endTime, CancellationToken cancellationToken)
         {
-            throw new NotImplementedException();
+            if (loadBalancerId == null)
+                throw new ArgumentNullException("loadBalancerId");
+            if (endTime < startTime)
+                throw new ArgumentOutOfRangeException("endTime");
+
+            UriTemplate template = new UriTemplate("/loadbalancers/{loadBalancerId}/usage?startTime={startTime}&endTime={endTime}");
+            var parameters = new Dictionary<string, string> { { "loadBalancerId", loadBalancerId.Value } };
+            if (startTime != null)
+                parameters.Add("startTime", startTime.Value.ToString("yyyy-MM-dd"));
+            if (endTime != null)
+                parameters.Add("endTime", endTime.Value.ToString("yyyy-MM-dd"));
+
+            Func<Task<Tuple<IdentityToken, Uri>>, HttpWebRequest> prepareRequest =
+                PrepareRequestAsyncFunc(HttpMethod.GET, template, parameters);
+
+            Func<Task<HttpWebRequest>, Task<ListLoadBalancerUsageResponse>> requestResource =
+                GetResponseAsyncFunc<ListLoadBalancerUsageResponse>(cancellationToken);
+
+            Func<Task<ListLoadBalancerUsageResponse>, IEnumerable<LoadBalancerUsage>> resultSelector =
+                task => (task.Result != null ? task.Result.UsageRecords : null) ?? Enumerable.Empty<LoadBalancerUsage>();
+
+            return AuthenticateServiceAsync(cancellationToken)
+                .ContinueWith(prepareRequest)
+                .ContinueWith(requestResource).Unwrap()
+                .ContinueWith(resultSelector);
         }
 
         /// <inheritdoc/>
         public Task<IEnumerable<LoadBalancerUsage>> ListCurrentUsageAsync(LoadBalancerId loadBalancerId, CancellationToken cancellationToken)
         {
-            throw new NotImplementedException();
+            if (loadBalancerId == null)
+                throw new ArgumentNullException("loadBalancerId");
+
+            UriTemplate template = new UriTemplate("/loadbalancers/{loadBalancerId}/usage/current");
+            var parameters = new Dictionary<string, string> { { "loadBalancerId", loadBalancerId.Value } };
+
+            Func<Task<Tuple<IdentityToken, Uri>>, HttpWebRequest> prepareRequest =
+                PrepareRequestAsyncFunc(HttpMethod.GET, template, parameters);
+
+            Func<Task<HttpWebRequest>, Task<ListLoadBalancerUsageResponse>> requestResource =
+                GetResponseAsyncFunc<ListLoadBalancerUsageResponse>(cancellationToken);
+
+            Func<Task<ListLoadBalancerUsageResponse>, IEnumerable<LoadBalancerUsage>> resultSelector =
+                task => (task.Result != null ? task.Result.UsageRecords : null) ?? Enumerable.Empty<LoadBalancerUsage>();
+
+            return AuthenticateServiceAsync(cancellationToken)
+                .ContinueWith(prepareRequest)
+                .ContinueWith(requestResource).Unwrap()
+                .ContinueWith(resultSelector);
         }
 
         /// <inheritdoc/>
@@ -1243,19 +1338,108 @@ public Task ClearAccessListAsync(LoadBalancerId loadBalancerId, AsyncCompletionO
         /// <inheritdoc/>
         public Task<HealthMonitor> GetHealthMonitorAsync(LoadBalancerId loadBalancerId, CancellationToken cancellationToken)
         {
-            throw new NotImplementedException();
+            if (loadBalancerId == null)
+                throw new ArgumentNullException("loadBalancerId");
+
+            UriTemplate template = new UriTemplate("/loadbalancers/{loadBalancerId}/healthmonitor");
+            var parameters = new Dictionary<string, string>()
+            {
+                { "loadBalancerId", loadBalancerId.Value }
+            };
+
+            Func<Task<Tuple<IdentityToken, Uri>>, HttpWebRequest> prepareRequest =
+                PrepareRequestAsyncFunc(HttpMethod.GET, template, parameters);
+
+            Func<Task<HttpWebRequest>, Task<JObject>> requestResource =
+                GetResponseAsyncFunc<JObject>(cancellationToken);
+
+            Func<Task<JObject>, HealthMonitor> resultSelector =
+                task =>
+                {
+                    if (task.Result == null)
+                        return null;
+
+                    JObject healthMonitorObject = task.Result["healthMonitor"] as JObject;
+                    if (healthMonitorObject == null)
+                        return null;
+
+                    return HealthMonitor.FromJObject(healthMonitorObject);
+                };
+
+            return AuthenticateServiceAsync(cancellationToken)
+                .ContinueWith(prepareRequest)
+                .ContinueWith(requestResource).Unwrap()
+                .ContinueWith(resultSelector);
         }
 
         /// <inheritdoc/>
         public Task SetHealthMonitorAsync(LoadBalancerId loadBalancerId, HealthMonitor monitor, AsyncCompletionOption completionOption, CancellationToken cancellationToken, IProgress<LoadBalancer> progress)
         {
-            throw new NotImplementedException();
+            if (loadBalancerId == null)
+                throw new ArgumentNullException("loadBalancerId");
+            if (monitor == null)
+                throw new ArgumentNullException("monitor");
+
+            UriTemplate template = new UriTemplate("/loadbalancers/{loadBalancerId}/healthmonitor");
+            var parameters = new Dictionary<string, string>()
+            {
+                { "loadBalancerId", loadBalancerId.Value }
+            };
+
+            Func<Task<Tuple<IdentityToken, Uri>>, Task<HttpWebRequest>> prepareRequest =
+                PrepareRequestAsyncFunc(HttpMethod.PUT, template, parameters, monitor);
+
+            Func<Task<HttpWebRequest>, Task<string>> requestResource =
+                GetResponseAsyncFunc(cancellationToken);
+
+            Func<Task<string>, Task<LoadBalancer>> resultSelector =
+                task =>
+                {
+                    task.PropagateExceptions();
+                    if (completionOption == AsyncCompletionOption.RequestCompleted)
+                        return WaitForLoadBalancerToLeaveStateAsync(loadBalancerId, LoadBalancerStatus.PendingUpdate, cancellationToken, progress);
+
+                    return InternalTaskExtensions.CompletedTask(default(LoadBalancer));
+                };
+
+            return AuthenticateServiceAsync(cancellationToken)
+                .ContinueWith(prepareRequest).Unwrap()
+                .ContinueWith(requestResource).Unwrap()
+                .ContinueWith(resultSelector).Unwrap();
         }
 
         /// <inheritdoc/>
         public Task RemoveHealthMonitorAsync(LoadBalancerId loadBalancerId, AsyncCompletionOption completionOption, CancellationToken cancellationToken, IProgress<LoadBalancer> progress)
         {
-            throw new NotImplementedException();
+            if (loadBalancerId == null)
+                throw new ArgumentNullException("loadBalancerId");
+
+            UriTemplate template = new UriTemplate("/loadbalancers/{loadBalancerId}/healthmonitor");
+            var parameters = new Dictionary<string, string>()
+            {
+                { "loadBalancerId", loadBalancerId.Value },
+            };
+
+            Func<Task<Tuple<IdentityToken, Uri>>, HttpWebRequest> prepareRequest =
+                PrepareRequestAsyncFunc(HttpMethod.DELETE, template, parameters);
+
+            Func<Task<HttpWebRequest>, Task<string>> requestResource =
+                GetResponseAsyncFunc(cancellationToken);
+
+            Func<Task<string>, Task<LoadBalancer>> resultSelector =
+                task =>
+                {
+                    task.PropagateExceptions();
+                    if (completionOption == AsyncCompletionOption.RequestCompleted)
+                        return WaitForLoadBalancerToLeaveStateAsync(loadBalancerId, LoadBalancerStatus.PendingUpdate, cancellationToken, progress);
+
+                    return InternalTaskExtensions.CompletedTask(default(LoadBalancer));
+                };
+
+            return AuthenticateServiceAsync(cancellationToken)
+                .ContinueWith(prepareRequest)
+                .ContinueWith(requestResource).Unwrap()
+                .ContinueWith(resultSelector).Unwrap();
         }
 
         /// <inheritdoc/>
diff --git a/src/corelib/Providers/Rackspace/Objects/LoadBalancers/CustomHealthMonitor.cs b/src/corelib/Providers/Rackspace/Objects/LoadBalancers/CustomHealthMonitor.cs
new file mode 100644
index 000000000..a9a41df7e
--- /dev/null
+++ b/src/corelib/Providers/Rackspace/Objects/LoadBalancers/CustomHealthMonitor.cs
@@ -0,0 +1,22 @@
+namespace net.openstack.Providers.Rackspace.Objects.LoadBalancers
+{
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// This class models the JSON object used to represent a custom <see cref="HealthMonitor"/>.
+    /// </summary>
+    /// <threadsafety static="true" instance="false"/>
+    /// <preliminary/>
+    [JsonObject(MemberSerialization.OptIn)]
+    public class CustomHealthMonitor : HealthMonitor
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CustomHealthMonitor"/> class
+        /// during JSON deserialization.
+        /// </summary>
+        [JsonConstructor]
+        protected CustomHealthMonitor()
+        {
+        }
+    }
+}
diff --git a/src/corelib/Providers/Rackspace/Objects/LoadBalancers/HealthMonitor.cs b/src/corelib/Providers/Rackspace/Objects/LoadBalancers/HealthMonitor.cs
index e104fdca1..767f8e7e7 100644
--- a/src/corelib/Providers/Rackspace/Objects/LoadBalancers/HealthMonitor.cs
+++ b/src/corelib/Providers/Rackspace/Objects/LoadBalancers/HealthMonitor.cs
@@ -2,6 +2,7 @@
 {
     using System;
     using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
 
     /// <summary>
     /// This is the base class for load balancer health monitoring configurations.
@@ -13,7 +14,6 @@
     /// <threadsafety static="true" instance="false"/>
     /// <preliminary/>
     [JsonObject(MemberSerialization.OptIn)]
-    [JsonConverter(typeof(HealthMonitor.Converter))]
     public abstract class HealthMonitor
     {
         /// <summary>
@@ -131,26 +131,28 @@ public int? AttemptsBeforeDeactivation
             }
         }
 
-        /// <inheritdoc/>
-        protected class Converter : JsonConverter
+        /// <summary>
+        /// Deserializes a JSON object to a <see cref="HealthMonitor"/> instance of the proper type.
+        /// </summary>
+        /// <param name="jsonObject">The JSON object representing the health monitor.</param>
+        /// <returns>A <see cref="HealthMonitor"/> object corresponding to the JSON object.</returns>
+        /// <exception cref="ArgumentNullException">If <paramref name="jsonObject"/> is <c>null</c>.</exception>
+        public static HealthMonitor FromJObject(JObject jsonObject)
         {
-            /// <inheritdoc/>
-            public override bool CanConvert(Type objectType)
-            {
-                throw new NotImplementedException();
-            }
-
-            /// <inheritdoc/>
-            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-            {
-                throw new NotImplementedException();
-            }
-
-            /// <inheritdoc/>
-            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-            {
-                throw new NotImplementedException();
-            }
+            if (jsonObject == null)
+                throw new ArgumentNullException("jsonObject");
+
+            JValue typeValue = jsonObject["type"] as JValue;
+            if (typeValue == null)
+                return null;
+
+            HealthMonitorType type = typeValue.ToObject<HealthMonitorType>();
+            if (type == HealthMonitorType.Connect)
+                return jsonObject.ToObject<ConnectionHealthMonitor>();
+            else if (type == HealthMonitorType.Http || type == HealthMonitorType.Https)
+                return jsonObject.ToObject<WebServerHealthMonitor>();
+            else
+                return jsonObject.ToObject<CustomHealthMonitor>();
         }
     }
 }
diff --git a/src/corelib/Providers/Rackspace/Objects/LoadBalancers/LoadBalancerConfiguration`1.cs b/src/corelib/Providers/Rackspace/Objects/LoadBalancers/LoadBalancerConfiguration`1.cs
index 05ffa2a20..3747cfa51 100644
--- a/src/corelib/Providers/Rackspace/Objects/LoadBalancers/LoadBalancerConfiguration`1.cs
+++ b/src/corelib/Providers/Rackspace/Objects/LoadBalancers/LoadBalancerConfiguration`1.cs
@@ -5,6 +5,7 @@
     using System.Collections.ObjectModel;
     using System.Linq;
     using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
 
     /// <summary>
     /// Represents a load balancer configuration.
@@ -86,7 +87,7 @@ public class LoadBalancerConfiguration<TNodeConfiguration>
         /// This is the backing field for the <see cref="HealthMonitor"/> property.
         /// </summary>
         [JsonProperty("healthMonitor", DefaultValueHandling = DefaultValueHandling.Ignore)]
-        private HealthMonitor _healthMonitor;
+        private JObject _healthMonitor;
 
         /// <summary>
         /// This is the backing field for the <see cref="Metadata"/> property.
@@ -190,7 +191,7 @@ public LoadBalancerConfiguration(string name, LoadBalancingProtocol protocol, IE
             if (contentCaching.HasValue)
                 _contentCaching = contentCaching.Value ? LoadBalancerEnabledFlag.True : LoadBalancerEnabledFlag.False;
             _connectionThrottle = connectionThrottle;
-            _healthMonitor = healthMonitor;
+            _healthMonitor = healthMonitor != null ? JObject.FromObject(healthMonitor) : null;
             _metadata = metadata != null ? metadata.ToArray() : null;
             _timeout = timeout != null ? (int?)timeout.Value.TotalSeconds : null;
             _sessionPersistence = sessionPersistence;
@@ -340,7 +341,10 @@ public HealthMonitor HealthMonitor
         {
             get
             {
-                return _healthMonitor;
+                if (_healthMonitor == null)
+                    return null;
+
+                return HealthMonitor.FromJObject(_healthMonitor);
             }
         }
 
diff --git a/src/corelib/Providers/Rackspace/Objects/LoadBalancers/Response/ListLoadBalancerUsageResponse.cs b/src/corelib/Providers/Rackspace/Objects/LoadBalancers/Response/ListLoadBalancerUsageResponse.cs
new file mode 100644
index 000000000..52a28d508
--- /dev/null
+++ b/src/corelib/Providers/Rackspace/Objects/LoadBalancers/Response/ListLoadBalancerUsageResponse.cs
@@ -0,0 +1,47 @@
+namespace net.openstack.Providers.Rackspace.Objects.LoadBalancers.Response
+{
+    using System.Collections.ObjectModel;
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// This models the JSON response used for the List Usage request.
+    /// </summary>
+    /// <seealso href="http://docs.rackspace.com/loadbalancers/api/v1.0/clb-devguide/content/List_Usage-d1e3014.html">List Usage (Rackspace Cloud Load Balancers Developer Guide - API v1.0)</seealso>
+    /// <threadsafety static="true" instance="false"/>
+    /// <preliminary/>
+    [JsonObject(MemberSerialization.OptIn)]
+    internal class ListLoadBalancerUsageResponse
+    {
+#pragma warning disable 649 // Field 'fieldName' is never assigned to, and will always have its default value
+        /// <summary>
+        /// This is the backing field for the <see cref="UsageRecords"/> property.
+        /// </summary>
+        [JsonProperty("loadBalancerUsageRecords")]
+        private LoadBalancerUsage[] _loadBalancerUsage;
+#pragma warning restore 649
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ListLoadBalancerUsageResponse"/> class
+        /// during JSON deserialization.
+        /// </summary>
+        [JsonConstructor]
+        protected ListLoadBalancerUsageResponse()
+        {
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="LoadBalancerUsage"/> objects describing the load
+        /// balancer usage resources in a load balancer service provider.
+        /// </summary>
+        public ReadOnlyCollection<LoadBalancerUsage> UsageRecords
+        {
+            get
+            {
+                if (_loadBalancerUsage == null)
+                    return null;
+
+                return new ReadOnlyCollection<LoadBalancerUsage>(_loadBalancerUsage);
+            }
+        }
+    }
+}
diff --git a/src/corelib/corelib.v3.5.csproj b/src/corelib/corelib.v3.5.csproj
index 7e90cee9b..f04e8f70a 100644
--- a/src/corelib/corelib.v3.5.csproj
+++ b/src/corelib/corelib.v3.5.csproj
@@ -236,6 +236,7 @@
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\AccessType.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\ConnectionHealthMonitor.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\ConnectionThrottles.cs" />
+    <Compile Include="Providers\Rackspace\Objects\LoadBalancers\CustomHealthMonitor.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\HealthMonitor.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\HealthMonitorType.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\LoadBalancer.cs" />
@@ -273,6 +274,7 @@
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\NodeType.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\NodeUpdate.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Request\NamespaceDoc.cs" />
+    <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\ListLoadBalancerUsageResponse.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\NamespaceDoc.cs" />
     <Compile Include="Providers\Rackspace\Objects\Queues\NamespaceDoc.cs" />
     <Compile Include="Providers\Rackspace\Objects\Queues\Request\ClaimMessagesRequest.cs" />
diff --git a/src/corelib/corelib.v4.0.csproj b/src/corelib/corelib.v4.0.csproj
index 09520ff39..f9365b2b3 100644
--- a/src/corelib/corelib.v4.0.csproj
+++ b/src/corelib/corelib.v4.0.csproj
@@ -227,6 +227,7 @@
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\AccessType.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\ConnectionHealthMonitor.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\ConnectionThrottles.cs" />
+    <Compile Include="Providers\Rackspace\Objects\LoadBalancers\CustomHealthMonitor.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\HealthMonitor.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\HealthMonitorType.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\LoadBalancer.cs" />
@@ -287,6 +288,7 @@
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\ListLoadBalancerNodesResponse.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\ListLoadBalancersResponse.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\ListLoadBalancerThrottlesResponse.cs" />
+    <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\ListLoadBalancerUsageResponse.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\ListLoadBalancingAlgorithmsResponse.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\ListLoadBalancingProtocolsResponse.cs" />
     <Compile Include="Providers\Rackspace\Objects\LoadBalancers\Response\ListNodeServiceEventsResponse.cs" />
diff --git a/src/testing/integration/Providers/Rackspace/UserLoadBalancerTests.cs b/src/testing/integration/Providers/Rackspace/UserLoadBalancerTests.cs
index ab960bb9b..a8e69f70c 100644
--- a/src/testing/integration/Providers/Rackspace/UserLoadBalancerTests.cs
+++ b/src/testing/integration/Providers/Rackspace/UserLoadBalancerTests.cs
@@ -692,33 +692,153 @@ public async Task TestListAllowedDomains()
         [TestMethod]
         [TestCategory(TestCategories.User)]
         [TestCategory(TestCategories.LoadBalancers)]
-        public void TestListBillableLoadBalancers()
+        public async Task TestListBillableLoadBalancers()
         {
-            Assert.Inconclusive("Not yet implemented.");
+            ILoadBalancerService provider = CreateProvider();
+            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60))))
+            {
+                IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token);
+                LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase));
+
+                string loadBalancerName = CreateRandomLoadBalancerName();
+
+                LoadBalancerConfiguration configuration = new LoadBalancerConfiguration(
+                    name: loadBalancerName,
+                    nodes: null,
+                    protocol: httpProtocol,
+                    virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) },
+                    algorithm: LoadBalancingAlgorithm.RoundRobin);
+                LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                IEnumerable<LoadBalancer> billable = await provider.ListBillableLoadBalancersAsync(DateTimeOffset.Now.Date.AddDays(-60), DateTimeOffset.Now.Date.AddDays(1), null, null, cancellationTokenSource.Token);
+                Assert.IsNotNull(billable);
+                LoadBalancer[] loadBalancers = billable.ToArray();
+                if (loadBalancers.Length == 0)
+                    Assert.Inconclusive("No billable load balancers were reported.");
+
+                Console.WriteLine("Billable Load Balancers:");
+                foreach (LoadBalancer loadBalancer in loadBalancers)
+                    Console.WriteLine("  {0}", loadBalancer.Id);
+
+                /* Cleanup
+                 */
+
+                await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+            }
         }
 
         [TestMethod]
         [TestCategory(TestCategories.User)]
         [TestCategory(TestCategories.LoadBalancers)]
-        public void TestListAccountLevelUsage()
+        public async Task TestListAccountLevelUsage()
         {
-            Assert.Inconclusive("Not yet implemented.");
+            ILoadBalancerService provider = CreateProvider();
+            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60))))
+            {
+                IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token);
+                LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase));
+
+                string loadBalancerName = CreateRandomLoadBalancerName();
+
+                LoadBalancerConfiguration configuration = new LoadBalancerConfiguration(
+                    name: loadBalancerName,
+                    nodes: null,
+                    protocol: httpProtocol,
+                    virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) },
+                    algorithm: LoadBalancingAlgorithm.RoundRobin);
+                LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                IEnumerable<LoadBalancerUsage> usage = await provider.ListAccountLevelUsageAsync(DateTimeOffset.Now.Date.AddDays(-60), DateTimeOffset.Now.Date.AddDays(1), cancellationTokenSource.Token);
+                Assert.IsNotNull(usage);
+                LoadBalancerUsage[] usageRecords = usage.ToArray();
+                if (usageRecords.Length == 0)
+                    Assert.Inconclusive("No account level usage was reported.");
+
+                Console.WriteLine("Account Level Usage ({0} records)", usageRecords.Length);
+                foreach (LoadBalancerUsage usageRecord in usageRecords)
+                    Console.WriteLine(JsonConvert.SerializeObject(usageRecord, Formatting.Indented));
+
+                /* Cleanup
+                 */
+
+                await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+            }
         }
 
         [TestMethod]
         [TestCategory(TestCategories.User)]
         [TestCategory(TestCategories.LoadBalancers)]
-        public void TestListHistoricalUsage()
+        public async Task TestListHistoricalUsage()
         {
-            Assert.Inconclusive("Not yet implemented.");
+            ILoadBalancerService provider = CreateProvider();
+            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60))))
+            {
+                IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token);
+                LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase));
+
+                string loadBalancerName = CreateRandomLoadBalancerName();
+
+                LoadBalancerConfiguration configuration = new LoadBalancerConfiguration(
+                    name: loadBalancerName,
+                    nodes: null,
+                    protocol: httpProtocol,
+                    virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) },
+                    algorithm: LoadBalancingAlgorithm.RoundRobin);
+                LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                IEnumerable<LoadBalancerUsage> usage = await provider.ListHistoricalUsageAsync(tempLoadBalancer.Id, DateTimeOffset.Now.Date.AddDays(-60), DateTimeOffset.Now.Date.AddDays(1), cancellationTokenSource.Token);
+                Assert.IsNotNull(usage);
+                LoadBalancerUsage[] usageRecords = usage.ToArray();
+                if (usageRecords.Length == 0)
+                    Assert.Inconclusive("No historical usage was reported for load balancer: {0}", tempLoadBalancer.Id);
+
+                Console.WriteLine("Historical Load Balancer Usage ({0} records)", usageRecords.Length);
+                foreach (LoadBalancerUsage usageRecord in usageRecords)
+                    Console.WriteLine(JsonConvert.SerializeObject(usageRecord, Formatting.Indented));
+
+                /* Cleanup
+                 */
+
+                await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+            }
         }
 
         [TestMethod]
         [TestCategory(TestCategories.User)]
         [TestCategory(TestCategories.LoadBalancers)]
-        public void TestListCurrentUsage()
+        public async Task TestListCurrentUsage()
         {
-            Assert.Inconclusive("Not yet implemented.");
+            ILoadBalancerService provider = CreateProvider();
+            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60))))
+            {
+                IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token);
+                LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase));
+
+                string loadBalancerName = CreateRandomLoadBalancerName();
+
+                LoadBalancerConfiguration configuration = new LoadBalancerConfiguration(
+                    name: loadBalancerName,
+                    nodes: null,
+                    protocol: httpProtocol,
+                    virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) },
+                    algorithm: LoadBalancingAlgorithm.RoundRobin);
+                LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                IEnumerable<LoadBalancerUsage> usage = await provider.ListCurrentUsageAsync(tempLoadBalancer.Id, cancellationTokenSource.Token);
+                Assert.IsNotNull(usage);
+                LoadBalancerUsage[] usageRecords = usage.ToArray();
+                if (usageRecords.Length == 0)
+                    Assert.Inconclusive("No current usage was reported for load balancer: {0}", tempLoadBalancer.Id);
+
+                Console.WriteLine("Current Load Balancer Usage ({0} records)", usageRecords.Length);
+                foreach (LoadBalancerUsage usageRecord in usageRecords)
+                    Console.WriteLine(JsonConvert.SerializeObject(usageRecord, Formatting.Indented));
+
+                /* Cleanup
+                 */
+
+                await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+            }
         }
 
         [TestMethod]
@@ -863,6 +983,202 @@ public async Task TestAccessLists()
             }
         }
 
+        [TestMethod]
+        [TestCategory(TestCategories.User)]
+        [TestCategory(TestCategories.LoadBalancers)]
+        public async Task TestHealthMonitorConnection()
+        {
+            ILoadBalancerService provider = CreateProvider();
+            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60))))
+            {
+                IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token);
+                LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("LDAP", StringComparison.OrdinalIgnoreCase));
+
+                string loadBalancerName = CreateRandomLoadBalancerName();
+
+                LoadBalancerConfiguration configuration = new LoadBalancerConfiguration(
+                    name: loadBalancerName,
+                    nodes: null,
+                    protocol: httpProtocol,
+                    virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) },
+                    algorithm: LoadBalancingAlgorithm.RoundRobin);
+                LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                // verify initially null
+                Assert.IsNull(tempLoadBalancer.HealthMonitor);
+                Assert.IsNull(await provider.GetHealthMonitorAsync(tempLoadBalancer.Id, cancellationTokenSource.Token));
+
+                // configure the health monitor
+                int attemptsBeforeDeactivation = 3;
+                TimeSpan timeout = TimeSpan.FromSeconds(30);
+                TimeSpan delay = TimeSpan.FromSeconds(30);
+                HealthMonitor monitor = new ConnectionHealthMonitor(attemptsBeforeDeactivation, timeout, delay);
+                await provider.SetHealthMonitorAsync(tempLoadBalancer.Id, monitor, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                // set the health monitor again
+                await provider.SetHealthMonitorAsync(tempLoadBalancer.Id, monitor, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                // verify the health monitor
+                HealthMonitor healthMonitor = await provider.GetHealthMonitorAsync(tempLoadBalancer.Id, cancellationTokenSource.Token);
+                Assert.IsInstanceOfType(healthMonitor, typeof(ConnectionHealthMonitor));
+                Assert.AreEqual(HealthMonitorType.Connect, healthMonitor.Type);
+                Assert.AreEqual(attemptsBeforeDeactivation, healthMonitor.AttemptsBeforeDeactivation);
+                Assert.AreEqual(timeout, healthMonitor.Timeout);
+                Assert.AreEqual(delay, healthMonitor.Delay);
+
+                // verify the information in the load balancer details
+                LoadBalancer loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token);
+                Assert.AreEqual(tempLoadBalancer.Id, loadBalancer.Id);
+
+                Assert.IsInstanceOfType(loadBalancer.HealthMonitor, typeof(ConnectionHealthMonitor));
+                Assert.AreEqual(HealthMonitorType.Connect, loadBalancer.HealthMonitor.Type);
+                Assert.AreEqual(attemptsBeforeDeactivation, loadBalancer.HealthMonitor.AttemptsBeforeDeactivation);
+                Assert.AreEqual(timeout, loadBalancer.HealthMonitor.Timeout);
+                Assert.AreEqual(delay, loadBalancer.HealthMonitor.Delay);
+
+                // remove the health monitor
+                await provider.RemoveHealthMonitorAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                // remove the health monitor again
+                try
+                {
+                    try
+                    {
+                        await provider.RemoveHealthMonitorAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+                    }
+                    catch (WebException ex)
+                    {
+                        throw new AggregateException(ex);
+                    }
+                }
+                catch (AggregateException aggregate)
+                {
+                    aggregate.Flatten().Handle(
+                        ex =>
+                        {
+                            WebException webException = ex as WebException;
+                            if (webException == null)
+                                return false;
+
+                            HttpWebResponse response = webException.Response as HttpWebResponse;
+                            if (response == null)
+                                return false;
+
+                            Assert.AreEqual((HttpStatusCode)422, response.StatusCode);
+                            return true;
+                        });
+                }
+
+                /* Cleanup
+                 */
+                await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+            }
+        }
+
+        [TestMethod]
+        [TestCategory(TestCategories.User)]
+        [TestCategory(TestCategories.LoadBalancers)]
+        public async Task TestHealthMonitorHttp()
+        {
+            ILoadBalancerService provider = CreateProvider();
+            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60))))
+            {
+                IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token);
+                LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase));
+
+                string loadBalancerName = CreateRandomLoadBalancerName();
+
+                LoadBalancerConfiguration configuration = new LoadBalancerConfiguration(
+                    name: loadBalancerName,
+                    nodes: null,
+                    protocol: httpProtocol,
+                    virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) },
+                    algorithm: LoadBalancingAlgorithm.RoundRobin);
+                LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                // verify initially null
+                Assert.IsNull(tempLoadBalancer.HealthMonitor);
+                Assert.IsNull(await provider.GetHealthMonitorAsync(tempLoadBalancer.Id, cancellationTokenSource.Token));
+
+                // configure the health monitor
+                bool https = false;
+                int attemptsBeforeDeactivation = 3;
+                TimeSpan timeout = TimeSpan.FromSeconds(30);
+                TimeSpan delay = TimeSpan.FromSeconds(30);
+                string bodyRegex = ".*";
+                string path = "/";
+                string statusRegex = ".*";
+                HealthMonitor monitor = new WebServerHealthMonitor(https, attemptsBeforeDeactivation, timeout, delay, bodyRegex, path, statusRegex);
+                await provider.SetHealthMonitorAsync(tempLoadBalancer.Id, monitor, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                // set the health monitor again
+                await provider.SetHealthMonitorAsync(tempLoadBalancer.Id, monitor, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                // verify the health monitor
+                HealthMonitor healthMonitor = await provider.GetHealthMonitorAsync(tempLoadBalancer.Id, cancellationTokenSource.Token);
+                Assert.IsInstanceOfType(healthMonitor, typeof(WebServerHealthMonitor));
+                WebServerHealthMonitor webServerHealthMonitor = (WebServerHealthMonitor)healthMonitor;
+                Assert.AreEqual(monitor.Type, healthMonitor.Type);
+                Assert.AreEqual(attemptsBeforeDeactivation, healthMonitor.AttemptsBeforeDeactivation);
+                Assert.AreEqual(timeout, healthMonitor.Timeout);
+                Assert.AreEqual(delay, healthMonitor.Delay);
+                Assert.AreEqual(bodyRegex, webServerHealthMonitor.BodyRegex);
+                Assert.AreEqual(path, webServerHealthMonitor.Path);
+                Assert.AreEqual(statusRegex, webServerHealthMonitor.StatusRegex);
+
+                // verify the information in the load balancer details
+                LoadBalancer loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token);
+                Assert.AreEqual(tempLoadBalancer.Id, loadBalancer.Id);
+
+                Assert.IsInstanceOfType(loadBalancer.HealthMonitor, typeof(WebServerHealthMonitor));
+                webServerHealthMonitor = (WebServerHealthMonitor)loadBalancer.HealthMonitor;
+                Assert.AreEqual(monitor.Type, loadBalancer.HealthMonitor.Type);
+                Assert.AreEqual(attemptsBeforeDeactivation, loadBalancer.HealthMonitor.AttemptsBeforeDeactivation);
+                Assert.AreEqual(timeout, loadBalancer.HealthMonitor.Timeout);
+                Assert.AreEqual(delay, loadBalancer.HealthMonitor.Delay);
+                Assert.AreEqual(bodyRegex, webServerHealthMonitor.BodyRegex);
+                Assert.AreEqual(path, webServerHealthMonitor.Path);
+                Assert.AreEqual(statusRegex, webServerHealthMonitor.StatusRegex);
+
+                // remove the health monitor
+                await provider.RemoveHealthMonitorAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                // remove the health monitor again
+                try
+                {
+                    try
+                    {
+                        await provider.RemoveHealthMonitorAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+                    }
+                    catch (WebException ex)
+                    {
+                        throw new AggregateException(ex);
+                    }
+                }
+                catch (AggregateException aggregate)
+                {
+                    aggregate.Flatten().Handle(
+                        ex =>
+                        {
+                            WebException webException = ex as WebException;
+                            if (webException == null)
+                                return false;
+
+                            HttpWebResponse response = webException.Response as HttpWebResponse;
+                            if (response == null)
+                                return false;
+
+                            Assert.AreEqual((HttpStatusCode)422, response.StatusCode);
+                            return true;
+                        });
+                }
+
+                /* Cleanup
+                 */
+                await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+            }
+        }
+
         [TestMethod]
         [TestCategory(TestCategories.User)]
         [TestCategory(TestCategories.LoadBalancers)]