From 9021d838366b20b906dbbd64b3096a44afc8e3f2 Mon Sep 17 00:00:00 2001
From: Simon Cropp <simon.cropp@gmail.com>
Date: Thu, 19 Apr 2018 11:09:19 +1000
Subject: [PATCH 1/5] redundant file

---
 Seq.Api.sln.DotSettings | 2 --
 1 file changed, 2 deletions(-)
 delete mode 100644 Seq.Api.sln.DotSettings

diff --git a/Seq.Api.sln.DotSettings b/Seq.Api.sln.DotSettings
deleted file mode 100644
index d50635d..0000000
--- a/Seq.Api.sln.DotSettings
+++ /dev/null
@@ -1,2 +0,0 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=AD/@EntryIndexedValue">AD</s:String></wpf:ResourceDictionary>
\ No newline at end of file

From afd494cab0b8036c5105ef0caa6a1338604c9839 Mon Sep 17 00:00:00 2001
From: Simon Cropp <simon.cropp@gmail.com>
Date: Thu, 19 Apr 2018 11:10:56 +1000
Subject: [PATCH 2/5] redundant usings

---
 example/SeqTail/Program.cs                          | 1 -
 src/Seq.Api/Model/Backups/BackupEntity.cs           | 4 +---
 src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs | 1 -
 src/Seq.Api/SeqConnection.cs                        | 2 +-
 4 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/example/SeqTail/Program.cs b/example/SeqTail/Program.cs
index 1504705..162fdd1 100644
--- a/example/SeqTail/Program.cs
+++ b/example/SeqTail/Program.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using System.Threading.Tasks;
 using DocoptNet;
 using Seq.Api;
diff --git a/src/Seq.Api/Model/Backups/BackupEntity.cs b/src/Seq.Api/Model/Backups/BackupEntity.cs
index a59bd0b..4631a56 100644
--- a/src/Seq.Api/Model/Backups/BackupEntity.cs
+++ b/src/Seq.Api/Model/Backups/BackupEntity.cs
@@ -1,6 +1,4 @@
-using System;
-
-namespace Seq.Api.Model.Backups
+namespace Seq.Api.Model.Backups
 {
     public class BackupEntity : Entity
     {
diff --git a/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs b/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
index 3064d4f..dee8d84 100644
--- a/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Seq.Api.Model.Inputs;
 using Seq.Api.Model.License;
 
 namespace Seq.Api.ResourceGroups
diff --git a/src/Seq.Api/SeqConnection.cs b/src/Seq.Api/SeqConnection.cs
index 9789aa5..a70c58b 100644
--- a/src/Seq.Api/SeqConnection.cs
+++ b/src/Seq.Api/SeqConnection.cs
@@ -18,7 +18,7 @@ public SeqConnection(string serverUrl, string apiKey = null, bool useDefaultCred
         {
             if (serverUrl == null) throw new ArgumentNullException(nameof(serverUrl));
             _client = new SeqApiClient(serverUrl, apiKey, useDefaultCredentials);
-            
+
             _root = new Lazy<Task<RootEntity>>(() => _client.GetRootAsync());
         }
 

From f57c675efa96739448a9bf41f58dece6f1faea56 Mon Sep 17 00:00:00 2001
From: Simon Cropp <simon.cropp@gmail.com>
Date: Thu, 19 Apr 2018 11:11:37 +1000
Subject: [PATCH 3/5] redundant file

---
 test/Seq.Api.Tests/Properties/AssemblyInfo.cs | 15 ---------------
 test/Seq.Api.Tests/Seq.Api.Tests.csproj       |  2 +-
 2 files changed, 1 insertion(+), 16 deletions(-)
 delete mode 100644 test/Seq.Api.Tests/Properties/AssemblyInfo.cs

diff --git a/test/Seq.Api.Tests/Properties/AssemblyInfo.cs b/test/Seq.Api.Tests/Properties/AssemblyInfo.cs
deleted file mode 100644
index 083fd7a..0000000
--- a/test/Seq.Api.Tests/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Seq.Api.Tests")]
-[assembly: AssemblyTrademark("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components.  If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
diff --git a/test/Seq.Api.Tests/Seq.Api.Tests.csproj b/test/Seq.Api.Tests/Seq.Api.Tests.csproj
index 397fd34..f522c93 100644
--- a/test/Seq.Api.Tests/Seq.Api.Tests.csproj
+++ b/test/Seq.Api.Tests/Seq.Api.Tests.csproj
@@ -27,4 +27,4 @@
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
 
-</Project>
+</Project>
\ No newline at end of file

From 66ad4e12b9232b7a977cdfc4604a71c7664c237c Mon Sep 17 00:00:00 2001
From: Simon Cropp <simon.cropp@gmail.com>
Date: Thu, 19 Apr 2018 14:47:20 +1000
Subject: [PATCH 4/5] CancellationToken

---
 Directory.Build.props                         |  6 ++
 src/Seq.Api/Client/SeqApiClient.cs            | 70 +++++++++---------
 .../ResourceGroups/ApiKeysResourceGroup.cs    | 25 +++----
 .../ResourceGroups/ApiResourceGroup.cs        | 72 ++++++++++---------
 .../AppInstancesResourceGroup.cs              | 30 ++++----
 .../ResourceGroups/AppsResourceGroup.cs       | 29 ++++----
 .../ResourceGroups/BackupsResourceGroup.cs    | 13 ++--
 .../ResourceGroups/DashboardsResourceGroup.cs | 25 +++----
 .../ResourceGroups/DataResourceGroup.cs       | 13 ++--
 .../DiagnosticsResourceGroup.cs               | 15 ++--
 .../ResourceGroups/EventsResourceGroup.cs     | 52 ++++++++------
 .../ExpressionsResourceGroup.cs               |  9 +--
 .../ResourceGroups/FeedsResourceGroup.cs      | 25 +++----
 src/Seq.Api/ResourceGroups/ISeqConnection.cs  |  3 +-
 .../ResourceGroups/LicensesResourceGroup.cs   | 21 +++---
 .../ResourceGroups/PermalinksResourceGroup.cs | 31 ++++----
 .../RetentionPoliciesResourceGroup.cs         | 25 +++----
 .../ResourceGroups/SettingsResourceGroup.cs   | 29 ++++----
 .../ResourceGroups/SignalsResourceGroup.cs    | 25 +++----
 .../ResourceGroups/SqlQueriesResourceGroup.cs | 25 +++----
 .../ResourceGroups/UpdatesResourceGroup.cs    |  5 +-
 .../ResourceGroups/UsersResourceGroup.cs      | 49 ++++++-------
 src/Seq.Api/Seq.Api.csproj                    |  2 +-
 src/Seq.Api/SeqConnection.cs                  | 13 ++--
 24 files changed, 326 insertions(+), 286 deletions(-)
 create mode 100644 Directory.Build.props

diff --git a/Directory.Build.props b/Directory.Build.props
new file mode 100644
index 0000000..2deb00d
--- /dev/null
+++ b/Directory.Build.props
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <PropertyGroup>
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/src/Seq.Api/Client/SeqApiClient.cs b/src/Seq.Api/Client/SeqApiClient.cs
index bb5abfc..fb097a6 100644
--- a/src/Seq.Api/Client/SeqApiClient.cs
+++ b/src/Seq.Api/Client/SeqApiClient.cs
@@ -60,95 +60,95 @@ public SeqApiClient(string serverUrl, string apiKey = null, bool useDefaultCrede
 
         public HttpClient HttpClient => _httpClient;
 
-        public Task<RootEntity> GetRootAsync()
+        public Task<RootEntity> GetRootAsync(CancellationToken token = default)
         {
-            return HttpGetAsync<RootEntity>("api");
+            return HttpGetAsync<RootEntity>("api", token);
         }
 
-        public Task<TEntity> GetAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public Task<TEntity> GetAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
-            return HttpGetAsync<TEntity>(linkUri);
+            return HttpGetAsync<TEntity>(linkUri, token);
         }
 
-        public Task<string> GetStringAsync(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public Task<string> GetStringAsync(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
-            return HttpGetStringAsync(linkUri);
+            return HttpGetStringAsync(linkUri, token);
         }
 
-        public Task<List<TEntity>> ListAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public Task<List<TEntity>> ListAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
-            return HttpGetAsync<List<TEntity>>(linkUri);
+            return HttpGetAsync<List<TEntity>>(linkUri, token);
         }
 
-        public async Task PostAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task PostAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Post, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, token).ConfigureAwait(false);
             new StreamReader(stream).ReadToEnd();
         }
 
-        public async Task<TResponse> PostAsync<TEntity, TResponse>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task<TResponse> PostAsync<TEntity, TResponse>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Post, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, token).ConfigureAwait(false);
             return _serializer.Deserialize<TResponse>(new JsonTextReader(new StreamReader(stream)));
         }
 
-        public async Task<string> PostReadStringAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task<string> PostReadStringAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Post, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, token).ConfigureAwait(false);
             return await new StreamReader(stream).ReadToEndAsync();
         }
 
-        public async Task<Stream> PostReadStreamAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task<Stream> PostReadStreamAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Post, linkUri) { Content = MakeJsonContent(content) };
-            return await HttpSendAsync(request).ConfigureAwait(false);
+            return await HttpSendAsync(request, token).ConfigureAwait(false);
         }
 
-        public async Task PutAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task PutAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Put, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, token).ConfigureAwait(false);
             new StreamReader(stream).ReadToEnd();
         }
 
-        public async Task DeleteAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task DeleteAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Delete, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, token).ConfigureAwait(false);
             new StreamReader(stream).ReadToEnd();
         }
 
-        public async Task<TResponse> DeleteAsync<TEntity, TResponse>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task<TResponse> DeleteAsync<TEntity, TResponse>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Delete, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, token).ConfigureAwait(false);
             return _serializer.Deserialize<TResponse>(new JsonTextReader(new StreamReader(stream)));
         }
 
-        public async Task<ObservableStream<TEntity>> StreamAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public async Task<ObservableStream<TEntity>> StreamAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            return await WebSocketStreamAsync(entity, link, parameters, reader => _serializer.Deserialize<TEntity>(new JsonTextReader(reader)));
+            return await WebSocketStreamAsync(entity, link, parameters, reader => _serializer.Deserialize<TEntity>(new JsonTextReader(reader)), token);
         }
 
-        public async Task<ObservableStream<string>> StreamTextAsync(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public async Task<ObservableStream<string>> StreamTextAsync(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            return await WebSocketStreamAsync(entity, link, parameters, reader => reader.ReadToEnd());
+            return await WebSocketStreamAsync(entity, link, parameters, reader => reader.ReadToEnd(), token);
         }
 
-        async Task<ObservableStream<T>> WebSocketStreamAsync<T>(ILinked entity, string link, IDictionary<string, object> parameters, Func<TextReader, T> deserialize)
+        async Task<ObservableStream<T>> WebSocketStreamAsync<T>(ILinked entity, string link, IDictionary<string, object> parameters, Func<TextReader, T> deserialize, CancellationToken token = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
 
@@ -157,35 +157,35 @@ async Task<ObservableStream<T>> WebSocketStreamAsync<T>(ILinked entity, string l
             if (_apiKey != null)
                 socket.Options.SetRequestHeader("X-Seq-ApiKey", _apiKey);
 
-            await socket.ConnectAsync(new Uri(linkUri), CancellationToken.None);
+            await socket.ConnectAsync(new Uri(linkUri), token);
 
             return new ObservableStream<T>(socket, deserialize);
         }
 
-        async Task<T> HttpGetAsync<T>(string url)
+        async Task<T> HttpGetAsync<T>(string url, CancellationToken token = default)
         {
             var request = new HttpRequestMessage(HttpMethod.Get, url);
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, token).ConfigureAwait(false);
             return _serializer.Deserialize<T>(new JsonTextReader(new StreamReader(stream)));
         }
 
-        async Task<string> HttpGetStringAsync(string url)
+        async Task<string> HttpGetStringAsync(string url, CancellationToken token = default)
         {
             var request = new HttpRequestMessage(HttpMethod.Get, url);
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, token).ConfigureAwait(false);
             return await new StreamReader(stream).ReadToEndAsync();
         }
 
-        async Task<Stream> HttpSendAsync(HttpRequestMessage request)
+        async Task<Stream> HttpSendAsync(HttpRequestMessage request, CancellationToken token = default)
         {
             if (_apiKey != null)
                 request.Headers.Add("X-Seq-ApiKey", _apiKey);
 
             request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(SeqApiV6MediaType));
 
-            var response = await _httpClient.SendAsync(request).ConfigureAwait(false);
+            var response = await _httpClient.SendAsync(request, token).ConfigureAwait(false);
             var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-            
+
             if (response.IsSuccessStatusCode)
                 return stream;
 
diff --git a/src/Seq.Api/ResourceGroups/ApiKeysResourceGroup.cs b/src/Seq.Api/ResourceGroups/ApiKeysResourceGroup.cs
index 6047ff2..f46b805 100644
--- a/src/Seq.Api/ResourceGroups/ApiKeysResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/ApiKeysResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Inputs;
 
@@ -12,36 +13,36 @@ internal ApiKeysResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<ApiKeyEntity> FindAsync(string id)
+        public async Task<ApiKeyEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<ApiKeyEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<ApiKeyEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<ApiKeyEntity>> ListAsync(string ownerId = null)
+        public async Task<List<ApiKeyEntity>> ListAsync(string ownerId = null, CancellationToken token = default)
         {
             var parameters = new Dictionary<string, object> { { "ownerId", ownerId } };
-            return await GroupListAsync<ApiKeyEntity>("Items", parameters).ConfigureAwait(false);
+            return await GroupListAsync<ApiKeyEntity>("Items", parameters, token).ConfigureAwait(false);
         }
 
-        public async Task<ApiKeyEntity> TemplateAsync()
+        public async Task<ApiKeyEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<ApiKeyEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<ApiKeyEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<ApiKeyEntity> AddAsync(ApiKeyEntity entity)
+        public async Task<ApiKeyEntity> AddAsync(ApiKeyEntity entity, CancellationToken token = default)
         {
-            return await GroupCreateAsync<ApiKeyEntity, ApiKeyEntity>(entity).ConfigureAwait(false);
+            return await GroupCreateAsync<ApiKeyEntity, ApiKeyEntity>(entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(ApiKeyEntity entity)
+        public async Task RemoveAsync(ApiKeyEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(ApiKeyEntity entity)
+        public async Task UpdateAsync(ApiKeyEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/ApiResourceGroup.cs b/src/Seq.Api/ResourceGroups/ApiResourceGroup.cs
index 23cf62b..97bd4e3 100644
--- a/src/Seq.Api/ResourceGroups/ApiResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/ApiResourceGroup.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Client;
 using Seq.Api.Model;
@@ -21,69 +22,69 @@ internal ApiResourceGroup(string name, ISeqConnection connection)
 
         protected SeqApiClient Client { get { return _connection.Client; } }
 
-        protected Task<ResourceGroup> LoadGroupAsync()
+        protected Task<ResourceGroup> LoadGroupAsync(CancellationToken token = default)
         {
-            return _connection.LoadResourceGroupAsync(_name);
+            return _connection.LoadResourceGroupAsync(_name, token);
         }
 
-        protected async Task<TEntity> GroupGetAsync<TEntity>(string link, IDictionary<string, object> parameters = null)
+        protected async Task<TEntity> GroupGetAsync<TEntity>(string link, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.GetAsync<TEntity>(group, link, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.GetAsync<TEntity>(group, link, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task<string> GroupGetStringAsync(string link, IDictionary<string, object> parameters = null)
+        protected async Task<string> GroupGetStringAsync(string link, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.GetStringAsync(group, link, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.GetStringAsync(group, link, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task<List<TEntity>> GroupListAsync<TEntity>(string link, IDictionary<string, object> parameters = null)
+        protected async Task<List<TEntity>> GroupListAsync<TEntity>(string link, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.ListAsync<TEntity>(group, link, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.ListAsync<TEntity>(group, link, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task GroupPostAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task GroupPostAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            await Client.PostAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            await Client.PostAsync(group, link, content, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task<string> GroupPostReadStringAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task<string> GroupPostReadStringAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.PostReadStringAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.PostReadStringAsync(group, link, content, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task<Stream> GroupPostReadBytesAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task<Stream> GroupPostReadBytesAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.PostReadStreamAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.PostReadStreamAsync(group, link, content, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task<TResponse> GroupPostAsync<TEntity, TResponse>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task<TResponse> GroupPostAsync<TEntity, TResponse>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.PostAsync<TEntity, TResponse>(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.PostAsync<TEntity, TResponse>(group, link, content, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task GroupPutAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task GroupPutAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            await Client.PutAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            await Client.PutAsync(group, link, content, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task GroupDeleteAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task GroupDeleteAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            await Client.DeleteAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            await Client.DeleteAsync(group, link, content, parameters, token).ConfigureAwait(false);
         }
 
-        protected async Task<TResponse> GroupDeleteAsync<TEntity, TResponse>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task<TResponse> GroupDeleteAsync<TEntity, TResponse>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken token = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.DeleteAsync<TEntity, TResponse>(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.DeleteAsync<TEntity, TResponse>(group, link, content, parameters, token).ConfigureAwait(false);
         }
 
         protected string GetLink<TEntity>(TEntity entity, string link, string orElse) where TEntity : ILinked
@@ -92,7 +93,8 @@ protected string GetLink<TEntity>(TEntity entity, string link, string orElse) wh
         }
 
         protected async Task<TResponse> GroupCreateAsync<TEntity, TResponse>(TEntity entity,
-            IDictionary<string, object> parameters = null) where TEntity : ILinked
+            IDictionary<string, object> parameters = null, CancellationToken token = default)
+            where TEntity : ILinked
         {
             ILinked resource;
             string link;
@@ -104,11 +106,11 @@ protected async Task<TResponse> GroupCreateAsync<TEntity, TResponse>(TEntity ent
             }
             else
             {
-                resource = await LoadGroupAsync().ConfigureAwait(false);
+                resource = await LoadGroupAsync(token).ConfigureAwait(false);
                 link = "Items";
             }
 
-            return await Client.PostAsync<TEntity, TResponse>(resource, link, entity, parameters).ConfigureAwait(false);
+            return await Client.PostAsync<TEntity, TResponse>(resource, link, entity, parameters, token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/AppInstancesResourceGroup.cs b/src/Seq.Api/ResourceGroups/AppInstancesResourceGroup.cs
index fe64248..7672744 100644
--- a/src/Seq.Api/ResourceGroups/AppInstancesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/AppInstancesResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.AppInstances;
 
@@ -12,48 +13,49 @@ internal AppInstancesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<AppInstanceEntity> FindAsync(string id)
+        public async Task<AppInstanceEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<AppInstanceEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<AppInstanceEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<AppInstanceEntity>> ListAsync()
+        public async Task<List<AppInstanceEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<AppInstanceEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<AppInstanceEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<AppInstanceEntity> TemplateAsync(string appId)
+        public async Task<AppInstanceEntity> TemplateAsync(string appId, CancellationToken token = default)
         {
             if (appId == null) throw new ArgumentNullException(nameof(appId));
-            return await GroupGetAsync<AppInstanceEntity>("Template", new Dictionary<string, object> { { "appId", appId } }).ConfigureAwait(false);
+            return await GroupGetAsync<AppInstanceEntity>("Template", new Dictionary<string, object> { { "appId", appId } }, token).ConfigureAwait(false);
         }
 
-        public async Task<AppInstanceEntity> AddAsync(AppInstanceEntity entity, bool runOnExisting = false)
+        public async Task<AppInstanceEntity> AddAsync(AppInstanceEntity entity, bool runOnExisting = false, CancellationToken token = default)
         {
             if (entity == null) throw new ArgumentNullException(nameof(entity));
-            return await Client.PostAsync<AppInstanceEntity, AppInstanceEntity>(entity, "Create", entity, new Dictionary<string, object> { { "runOnExisting", runOnExisting } }).ConfigureAwait(false);
+            return await Client.PostAsync<AppInstanceEntity, AppInstanceEntity>(entity, "Create", entity, new Dictionary<string, object> { { "runOnExisting", runOnExisting } }, token)
+                .ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(AppInstanceEntity entity)
+        public async Task RemoveAsync(AppInstanceEntity entity, CancellationToken token = default)
         {
             if (entity == null) throw new ArgumentNullException(nameof(entity));
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(AppInstanceEntity entity)
+        public async Task UpdateAsync(AppInstanceEntity entity, CancellationToken token = default)
         {
             if (entity == null) throw new ArgumentNullException(nameof(entity));
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task InvokeAsync(AppInstanceEntity entity, string eventId, IReadOnlyDictionary<string, string> settingOverrides)
+        public async Task InvokeAsync(AppInstanceEntity entity, string eventId, IReadOnlyDictionary<string, string> settingOverrides, CancellationToken token = default)
         {
             if (entity == null) throw new ArgumentNullException(nameof(entity));
             if (eventId == null) throw new ArgumentNullException(nameof(eventId));
 
             var postedSettings = settingOverrides ?? new Dictionary<string, string>();
-            await Client.PostAsync(entity, "Invoke", postedSettings, new Dictionary<string, object>{{"eventId", eventId}});
+            await Client.PostAsync(entity, "Invoke", postedSettings, new Dictionary<string, object>{{"eventId", eventId}}, token);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/AppsResourceGroup.cs b/src/Seq.Api/ResourceGroups/AppsResourceGroup.cs
index 6488b3b..a26cd7e 100644
--- a/src/Seq.Api/ResourceGroups/AppsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/AppsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Apps;
 
@@ -12,44 +13,44 @@ internal AppsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<AppEntity> FindAsync(string id)
+        public async Task<AppEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<AppEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<AppEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<AppEntity>> ListAsync()
+        public async Task<List<AppEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<AppEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<AppEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<AppEntity> TemplateAsync()
+        public async Task<AppEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<AppEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<AppEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<AppEntity> AddAsync(AppEntity entity)
+        public async Task<AppEntity> AddAsync(AppEntity entity, CancellationToken token = default)
         {
-            return await Client.PostAsync<AppEntity, AppEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<AppEntity, AppEntity>(entity, "Create", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(AppEntity entity)
+        public async Task RemoveAsync(AppEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(AppEntity entity)
+        public async Task UpdateAsync(AppEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task<AppEntity> InstallPackageAsync(string feedId, string packageId, string version = null)
+        public async Task<AppEntity> InstallPackageAsync(string feedId, string packageId, string version = null, CancellationToken token = default)
         {
             if (feedId == null) throw new ArgumentNullException(nameof(feedId));
             if (packageId == null) throw new ArgumentNullException(nameof(packageId));
             var parameters = new Dictionary<string, object>{{ "feedId", feedId}, {"packageId", packageId}};
             if (version != null) parameters.Add("version", version);
-            return await GroupPostAsync<object, AppEntity>("InstallPackage", new object(), parameters).ConfigureAwait(false);
+            return await GroupPostAsync<object, AppEntity>("InstallPackage", new object(), parameters, token).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/BackupsResourceGroup.cs b/src/Seq.Api/ResourceGroups/BackupsResourceGroup.cs
index 734d983..2b54591 100644
--- a/src/Seq.Api/ResourceGroups/BackupsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/BackupsResourceGroup.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Backups;
 
@@ -13,20 +14,20 @@ internal BackupsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<BackupEntity> FindAsync(string id)
+        public async Task<BackupEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<BackupEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<BackupEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<BackupEntity>> ListAsync()
+        public async Task<List<BackupEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<BackupEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<BackupEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<Stream> DownloadImmediateAsync()
+        public async Task<Stream> DownloadImmediateAsync(CancellationToken token = default)
         {
-            return await GroupPostReadBytesAsync("Immediate", new object()).ConfigureAwait(false);
+            return await GroupPostReadBytesAsync("Immediate", new object(), token: token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/DashboardsResourceGroup.cs b/src/Seq.Api/ResourceGroups/DashboardsResourceGroup.cs
index 39eee61..c0b96d5 100644
--- a/src/Seq.Api/ResourceGroups/DashboardsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/DashboardsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Monitoring;
 
@@ -12,36 +13,36 @@ internal DashboardsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<DashboardEntity> FindAsync(string id)
+        public async Task<DashboardEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<DashboardEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<DashboardEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<DashboardEntity>> ListAsync(string ownerId = null, bool shared = false)
+        public async Task<List<DashboardEntity>> ListAsync(string ownerId = null, bool shared = false, CancellationToken token = default)
         {
             var parameters = new Dictionary<string, object> { { "ownerId", ownerId }, { "shared", shared } };
-            return await GroupListAsync<DashboardEntity>("Items", parameters).ConfigureAwait(false);
+            return await GroupListAsync<DashboardEntity>("Items", parameters, token).ConfigureAwait(false);
         }
 
-        public async Task<DashboardEntity> TemplateAsync()
+        public async Task<DashboardEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<DashboardEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<DashboardEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<DashboardEntity> AddAsync(DashboardEntity entity)
+        public async Task<DashboardEntity> AddAsync(DashboardEntity entity, CancellationToken token = default)
         {
-            return await Client.PostAsync<DashboardEntity, DashboardEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<DashboardEntity, DashboardEntity>(entity, "Create", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(DashboardEntity entity)
+        public async Task RemoveAsync(DashboardEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(DashboardEntity entity)
+        public async Task UpdateAsync(DashboardEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/DataResourceGroup.cs b/src/Seq.Api/ResourceGroups/DataResourceGroup.cs
index 6a464f9..398e130 100644
--- a/src/Seq.Api/ResourceGroups/DataResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/DataResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Data;
 using Seq.Api.Model.Signals;
@@ -30,10 +31,11 @@ public async Task<QueryResultPart> QueryAsync(
             DateTime? rangeEndUtc = null,
             SignalExpressionPart signal = null,
             SignalEntity unsavedSignal = null,
-            TimeSpan? timeout = null)
+            TimeSpan? timeout = null,
+            CancellationToken token = default)
         {
             MakeParameters(query, rangeStartUtc, rangeEndUtc, signal, unsavedSignal, timeout, out var body, out var parameters);
-            return await GroupPostAsync<SignalEntity, QueryResultPart>("Query", body, parameters).ConfigureAwait(false);
+            return await GroupPostAsync<SignalEntity, QueryResultPart>("Query", body, parameters, token).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -53,11 +55,12 @@ public async Task<string> QueryCsvAsync(
             DateTime? rangeEndUtc = null,
             SignalExpressionPart signal = null,
             SignalEntity unsavedSignal = null,
-            TimeSpan? timeout = null)
+            TimeSpan? timeout = null,
+            CancellationToken token = default)
         {
             MakeParameters(query, rangeStartUtc, rangeEndUtc, signal, unsavedSignal, timeout, out var body, out var parameters);
             parameters.Add("format", "text/csv");
-            return await GroupPostReadStringAsync("Query", body, parameters).ConfigureAwait(false);
+            return await GroupPostReadStringAsync("Query", body, parameters, token).ConfigureAwait(false);
         }
 
         static void MakeParameters(
@@ -77,7 +80,7 @@ static void MakeParameters(
 
             if (rangeStartUtc != null)
                 parameters.Add(nameof(rangeStartUtc), rangeStartUtc);
-            
+
             if (rangeEndUtc != null)
                 parameters.Add(nameof(rangeEndUtc), rangeEndUtc.Value);
 
diff --git a/src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs b/src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs
index a983bd3..9844dfd 100644
--- a/src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Seq.Api.Model.Diagnostics;
 
 namespace Seq.Api.ResourceGroups
@@ -10,19 +11,19 @@ internal DiagnosticsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<ServerMetricsEntity> GetServerMetricsAsync()
+        public async Task<ServerMetricsEntity> GetServerMetricsAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<ServerMetricsEntity>("ServerMetrics").ConfigureAwait(false);
+            return await GroupGetAsync<ServerMetricsEntity>("ServerMetrics", token: token).ConfigureAwait(false);
         }
 
-        public async Task<ServerStatusPart> GetServerStatusAsync()
+        public async Task<ServerStatusPart> GetServerStatusAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<ServerStatusPart>("ServerStatus").ConfigureAwait(false);
+            return await GroupGetAsync<ServerStatusPart>("ServerStatus", token: token).ConfigureAwait(false);
         }
 
-        public async Task<string> GetIngestionLogAsync()
+        public async Task<string> GetIngestionLogAsync(CancellationToken token = default)
         {
-            return await GroupGetStringAsync("IngestionLog").ConfigureAwait(false);
+            return await GroupGetStringAsync("IngestionLog", token: token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/EventsResourceGroup.cs b/src/Seq.Api/ResourceGroups/EventsResourceGroup.cs
index 42d6862..db4d529 100644
--- a/src/Seq.Api/ResourceGroups/EventsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/EventsResourceGroup.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Events;
 using Seq.Api.Model.Shared;
@@ -26,13 +27,14 @@ internal EventsResourceGroup(ISeqConnection connection)
         public async Task<EventEntity> FindAsync(
             string id,
             bool render = false,
-            string permalinkId = null)
+            string permalinkId = null,
+            CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
 
             var parameters = new Dictionary<string, object> {{"id", id}};
 
-            return await GroupGetAsync<EventEntity>("Item", parameters).ConfigureAwait(false);
+            return await GroupGetAsync<EventEntity>("Item", parameters, token).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -57,7 +59,7 @@ public async Task<EventEntity> FindAsync(
         /// <returns>The complete list of events, ordered from least to most recent.</returns>
         public async Task<List<EventEntity>> ListAsync(
             SignalExpressionPart signal = null,
-            string filter = null, 
+            string filter = null,
             int count = 30,
             string startAtId = null,
             string afterId = null,
@@ -65,7 +67,8 @@ public async Task<List<EventEntity>> ListAsync(
             DateTime? fromDateUtc = null,
             DateTime? toDateUtc = null,
             int? shortCircuitAfter = null,
-            string permalinkId = null)
+            string permalinkId = null,
+            CancellationToken token = default)
         {
             var parameters = new Dictionary<string, object> { { "count", count } };
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
@@ -83,7 +86,7 @@ public async Task<List<EventEntity>> ListAsync(
 
             while (true)
             {
-                var resultSet = await GroupGetAsync<ResultSetPart>("InSignal", parameters).ConfigureAwait(false);
+                var resultSet = await GroupGetAsync<ResultSetPart>("InSignal", parameters, token).ConfigureAwait(false);
                 chunks.Add(resultSet.Events);
                 remaining -= resultSet.Events.Count;
 
@@ -129,15 +132,16 @@ public async Task<List<EventEntity>> ListAsync(
         public async Task<ResultSetPart> InSignalAsync(
             SignalEntity unsavedSignal = null,
             SignalExpressionPart signal = null,
-            string filter = null, 
+            string filter = null,
             int count = 30,
             string startAtId = null,
-            string afterId = null, 
+            string afterId = null,
             bool render = false,
             DateTime? fromDateUtc = null,
             DateTime? toDateUtc = null,
             int? shortCircuitAfter = null,
-            string permalinkId = null)
+            string permalinkId = null,
+            CancellationToken token = default)
         {
             var parameters = new Dictionary<string, object>{{ "count", count }};
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
@@ -151,7 +155,7 @@ public async Task<ResultSetPart> InSignalAsync(
             if (permalinkId != null) { parameters.Add("permalinkId", permalinkId); }
 
             var body = unsavedSignal ?? new SignalEntity();
-            return await GroupPostAsync<SignalEntity, ResultSetPart>("InSignal", body, parameters).ConfigureAwait(false);
+            return await GroupPostAsync<SignalEntity, ResultSetPart>("InSignal", body, parameters, token).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -176,15 +180,16 @@ public async Task<ResultSetPart> InSignalAsync(
         /// <returns>The complete list of events, ordered from least to most recent.</returns>
         public async Task<ResultSetPart> InSignalAsync(
             SignalExpressionPart signal,
-            string filter = null, 
+            string filter = null,
             int count = 30,
             string startAtId = null,
-            string afterId = null, 
+            string afterId = null,
             bool render = false,
             DateTime? fromDateUtc = null,
             DateTime? toDateUtc = null,
             int? shortCircuitAfter = null,
-            string permalinkId = null)
+            string permalinkId = null,
+            CancellationToken token = default)
         {
             if (signal == null) throw new ArgumentNullException(nameof(signal));
 
@@ -202,7 +207,7 @@ public async Task<ResultSetPart> InSignalAsync(
             if (shortCircuitAfter != null) { parameters.Add("shortCircuitAfter", shortCircuitAfter.Value); }
             if (permalinkId != null) { parameters.Add("permalinkId", permalinkId); }
 
-            return await GroupGetAsync<ResultSetPart>("InSignal", parameters).ConfigureAwait(false);
+            return await GroupGetAsync<ResultSetPart>("InSignal", parameters, token).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -219,9 +224,10 @@ public async Task<ResultSetPart> InSignalAsync(
         public async Task<DeleteResultPart> DeleteInSignalAsync(
             SignalEntity unsavedSignal = null,
             SignalExpressionPart signal = null,
-            string filter = null, 
+            string filter = null,
             DateTime? fromDateUtc = null,
-            DateTime? toDateUtc = null)
+            DateTime? toDateUtc = null,
+            CancellationToken token = default)
         {
             var parameters = new Dictionary<string, object>();
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
@@ -230,7 +236,7 @@ public async Task<DeleteResultPart> DeleteInSignalAsync(
             if (toDateUtc != null) { parameters.Add("toDateUtc", toDateUtc.Value); }
 
             var body = unsavedSignal ?? new SignalEntity();
-            return await GroupDeleteAsync<SignalEntity, DeleteResultPart>("DeleteInSignal", body, parameters).ConfigureAwait(false);
+            return await GroupDeleteAsync<SignalEntity, DeleteResultPart>("DeleteInSignal", body, parameters, token).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -244,14 +250,15 @@ public async Task<DeleteResultPart> DeleteInSignalAsync(
         /// subscriber connects, ensure at least one subscription is made in order to avoid event loss.</returns>
         public async Task<ObservableStream<T>> StreamAsync<T>(
             SignalExpressionPart signal = null,
-            string filter = null)
+            string filter = null,
+            CancellationToken token = default)
         {
             var parameters = new Dictionary<string, object>();
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
             if (filter != null) { parameters.Add("filter", filter); }
 
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.StreamAsync<T>(group, "Stream", parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.StreamAsync<T>(group, "Stream", parameters, token).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -265,14 +272,15 @@ public async Task<ObservableStream<T>> StreamAsync<T>(
         /// subscriber connects, ensure at least one subscription is made in order to avoid event loss.</returns>
         public async Task<ObservableStream<string>> StreamDocumentsAsync(
             SignalExpressionPart signal = null,
-            string filter = null)
+            string filter = null,
+            CancellationToken token = default)
         {
             var parameters = new Dictionary<string, object>();
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
             if (filter != null) { parameters.Add("filter", filter); }
 
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.StreamTextAsync(group, "Stream", parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(token).ConfigureAwait(false);
+            return await Client.StreamTextAsync(group, "Stream", parameters, token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/ExpressionsResourceGroup.cs b/src/Seq.Api/ResourceGroups/ExpressionsResourceGroup.cs
index c43d1c2..b39c23e 100644
--- a/src/Seq.Api/ResourceGroups/ExpressionsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/ExpressionsResourceGroup.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Expressions;
 
@@ -11,20 +12,20 @@ internal ExpressionsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public Task<ExpressionPart> ToStrictAsync(string fuzzy)
+        public Task<ExpressionPart> ToStrictAsync(string fuzzy, CancellationToken token = default)
         {
             return GroupGetAsync<ExpressionPart>("ToStrict", new Dictionary<string, object>
             {
                 {"fuzzy", fuzzy}
-            });
+            }, token);
         }
 
-        public Task<ExpressionPart> ToSqlAsync(string fuzzy)
+        public Task<ExpressionPart> ToSqlAsync(string fuzzy, CancellationToken token = default)
         {
             return GroupGetAsync<ExpressionPart>("ToSql", new Dictionary<string, object>
             {
                 {"fuzzy", fuzzy}
-            });
+            }, token);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/FeedsResourceGroup.cs b/src/Seq.Api/ResourceGroups/FeedsResourceGroup.cs
index 2e0bdec..5aafeb5 100644
--- a/src/Seq.Api/ResourceGroups/FeedsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/FeedsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Feeds;
 
@@ -12,35 +13,35 @@ internal FeedsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<NuGetFeedEntity> FindAsync(string id)
+        public async Task<NuGetFeedEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<NuGetFeedEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<NuGetFeedEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<NuGetFeedEntity>> ListAsync()
+        public async Task<List<NuGetFeedEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<NuGetFeedEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<NuGetFeedEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<NuGetFeedEntity> TemplateAsync()
+        public async Task<NuGetFeedEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<NuGetFeedEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<NuGetFeedEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<NuGetFeedEntity> AddAsync(NuGetFeedEntity entity)
+        public async Task<NuGetFeedEntity> AddAsync(NuGetFeedEntity entity, CancellationToken token = default)
         {
-            return await Client.PostAsync<NuGetFeedEntity, NuGetFeedEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<NuGetFeedEntity, NuGetFeedEntity>(entity, "Create", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(NuGetFeedEntity entity)
+        public async Task RemoveAsync(NuGetFeedEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(NuGetFeedEntity entity)
+        public async Task UpdateAsync(NuGetFeedEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/ISeqConnection.cs b/src/Seq.Api/ResourceGroups/ISeqConnection.cs
index cbdcb0c..ca9d9e8 100644
--- a/src/Seq.Api/ResourceGroups/ISeqConnection.cs
+++ b/src/Seq.Api/ResourceGroups/ISeqConnection.cs
@@ -1,3 +1,4 @@
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Client;
 using Seq.Api.Model;
@@ -6,7 +7,7 @@ namespace Seq.Api.ResourceGroups
 {
     interface ISeqConnection
     {
-        Task<ResourceGroup> LoadResourceGroupAsync(string name);
+        Task<ResourceGroup> LoadResourceGroupAsync(string name, CancellationToken cancellationToken = default);
         SeqApiClient Client { get; }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs b/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
index dee8d84..302ac93 100644
--- a/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.License;
 
@@ -12,30 +13,30 @@ internal LicensesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<LicenseEntity> FindAsync(string id)
+        public async Task<LicenseEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<LicenseEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<LicenseEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<LicenseEntity> FindCurrentAsync()
+        public async Task<LicenseEntity> FindCurrentAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<LicenseEntity>("Current").ConfigureAwait(false);
+            return await GroupGetAsync<LicenseEntity>("Current", token: token).ConfigureAwait(false);
         }
 
-        public async Task<List<LicenseEntity>> ListAsync()
+        public async Task<List<LicenseEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<LicenseEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<LicenseEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(LicenseEntity entity)
+        public async Task UpdateAsync(LicenseEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task DowngradeAsync()
+        public async Task DowngradeAsync(CancellationToken token = default)
         {
-            await GroupPostAsync("Downgrade", new object()).ConfigureAwait(false);
+            await GroupPostAsync("Downgrade", new object(), token: token).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/PermalinksResourceGroup.cs b/src/Seq.Api/ResourceGroups/PermalinksResourceGroup.cs
index a280d71..3fc3fd5 100644
--- a/src/Seq.Api/ResourceGroups/PermalinksResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/PermalinksResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Permalinks;
 
@@ -14,8 +15,9 @@ internal PermalinksResourceGroup(ISeqConnection connection)
 
         public async Task<PermalinkEntity> FindAsync(
             string id,
-            bool includeEvent = false, 
-            bool renderEvent = false)
+            bool includeEvent = false,
+            bool renderEvent = false,
+            CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
             var parameters = new Dictionary<string, object>
@@ -24,12 +26,13 @@ public async Task<PermalinkEntity> FindAsync(
                 {"includeEvent", includeEvent},
                 {"renderEvent", renderEvent}
             };
-            return await GroupGetAsync<PermalinkEntity>("Item", parameters).ConfigureAwait(false);
+            return await GroupGetAsync<PermalinkEntity>("Item", parameters, token).ConfigureAwait(false);
         }
 
         public async Task<List<PermalinkEntity>> ListAsync(
-            bool includeEvent = false, 
-            bool renderEvent = false)
+            bool includeEvent = false,
+            bool renderEvent = false,
+            CancellationToken token = default)
         {
             var parameters = new Dictionary<string, object>
             {
@@ -37,27 +40,27 @@ public async Task<List<PermalinkEntity>> ListAsync(
                 {"renderEvent", renderEvent}
             };
 
-            return await GroupListAsync<PermalinkEntity>("Items", parameters).ConfigureAwait(false);
+            return await GroupListAsync<PermalinkEntity>("Items", parameters, token).ConfigureAwait(false);
         }
 
-        public async Task<PermalinkEntity> TemplateAsync()
+        public async Task<PermalinkEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<PermalinkEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<PermalinkEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<PermalinkEntity> AddAsync(PermalinkEntity entity)
+        public async Task<PermalinkEntity> AddAsync(PermalinkEntity entity, CancellationToken token = default)
         {
-            return await GroupCreateAsync<PermalinkEntity, PermalinkEntity>(entity).ConfigureAwait(false);
+            return await GroupCreateAsync<PermalinkEntity, PermalinkEntity>(entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(PermalinkEntity entity)
+        public async Task RemoveAsync(PermalinkEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(PermalinkEntity entity)
+        public async Task UpdateAsync(PermalinkEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/RetentionPoliciesResourceGroup.cs b/src/Seq.Api/ResourceGroups/RetentionPoliciesResourceGroup.cs
index e750e41..430fad8 100644
--- a/src/Seq.Api/ResourceGroups/RetentionPoliciesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/RetentionPoliciesResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Retention;
 
@@ -12,35 +13,35 @@ internal RetentionPoliciesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<RetentionPolicyEntity> FindAsync(string id)
+        public async Task<RetentionPolicyEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<RetentionPolicyEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<RetentionPolicyEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<RetentionPolicyEntity>> ListAsync()
+        public async Task<List<RetentionPolicyEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<RetentionPolicyEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<RetentionPolicyEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<RetentionPolicyEntity> TemplateAsync()
+        public async Task<RetentionPolicyEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<RetentionPolicyEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<RetentionPolicyEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<RetentionPolicyEntity> AddAsync(RetentionPolicyEntity entity)
+        public async Task<RetentionPolicyEntity> AddAsync(RetentionPolicyEntity entity, CancellationToken token = default)
         {
-            return await Client.PostAsync<RetentionPolicyEntity, RetentionPolicyEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<RetentionPolicyEntity, RetentionPolicyEntity>(entity, "Create", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(RetentionPolicyEntity entity)
+        public async Task RemoveAsync(RetentionPolicyEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(RetentionPolicyEntity entity)
+        public async Task UpdateAsync(RetentionPolicyEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/SettingsResourceGroup.cs b/src/Seq.Api/ResourceGroups/SettingsResourceGroup.cs
index 1ec5292..15537e0 100644
--- a/src/Seq.Api/ResourceGroups/SettingsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/SettingsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Settings;
 
@@ -12,40 +13,40 @@ internal SettingsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<SettingEntity> FindAsync(string id)
+        public async Task<SettingEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<SettingEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<SettingEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<SettingEntity> FindNamedAsync(SettingName name)
+        public async Task<SettingEntity> FindNamedAsync(SettingName name, CancellationToken token = default)
         {
-            return await GroupGetAsync<SettingEntity>(name.ToString()).ConfigureAwait(false);
+            return await GroupGetAsync<SettingEntity>(name.ToString(), token: token).ConfigureAwait(false);
         }
 
-        public async Task<List<SettingEntity>> ListAsync()
+        public async Task<List<SettingEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<SettingEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<SettingEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<SettingEntity> TemplateAsync()
+        public async Task<SettingEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<SettingEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<SettingEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<SettingEntity> AddAsync(SettingEntity entity)
+        public async Task<SettingEntity> AddAsync(SettingEntity entity, CancellationToken token = default)
         {
-            return await Client.PostAsync<SettingEntity, SettingEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<SettingEntity, SettingEntity>(entity, "Create", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(SettingEntity entity)
+        public async Task RemoveAsync(SettingEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(SettingEntity entity)
+        public async Task UpdateAsync(SettingEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/SignalsResourceGroup.cs b/src/Seq.Api/ResourceGroups/SignalsResourceGroup.cs
index cf68e2b..c6b340f 100644
--- a/src/Seq.Api/ResourceGroups/SignalsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/SignalsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Signals;
 
@@ -12,35 +13,35 @@ internal SignalsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<SignalEntity> FindAsync(string id)
+        public async Task<SignalEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<SignalEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<SignalEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<SignalEntity>> ListAsync()
+        public async Task<List<SignalEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<SignalEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<SignalEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<SignalEntity> TemplateAsync()
+        public async Task<SignalEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<SignalEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<SignalEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<SignalEntity> AddAsync(SignalEntity entity)
+        public async Task<SignalEntity> AddAsync(SignalEntity entity, CancellationToken token = default)
         {
-            return await GroupCreateAsync<SignalEntity, SignalEntity>(entity).ConfigureAwait(false);
+            return await GroupCreateAsync<SignalEntity, SignalEntity>(entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(SignalEntity entity)
+        public async Task RemoveAsync(SignalEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(SignalEntity entity)
+        public async Task UpdateAsync(SignalEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/SqlQueriesResourceGroup.cs b/src/Seq.Api/ResourceGroups/SqlQueriesResourceGroup.cs
index 3b84725..3d3c074 100644
--- a/src/Seq.Api/ResourceGroups/SqlQueriesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/SqlQueriesResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.SqlQueries;
 
@@ -12,35 +13,35 @@ internal SqlQueriesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<SqlQueryEntity> FindAsync(string id)
+        public async Task<SqlQueryEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<SqlQueryEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<SqlQueryEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<List<SqlQueryEntity>> ListAsync()
+        public async Task<List<SqlQueryEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<SqlQueryEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<SqlQueryEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<SqlQueryEntity> TemplateAsync()
+        public async Task<SqlQueryEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<SqlQueryEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<SqlQueryEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<SqlQueryEntity> AddAsync(SqlQueryEntity entity)
+        public async Task<SqlQueryEntity> AddAsync(SqlQueryEntity entity, CancellationToken token = default)
         {
-            return await Client.PostAsync<SqlQueryEntity, SqlQueryEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<SqlQueryEntity, SqlQueryEntity>(entity, "Create", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(SqlQueryEntity entity)
+        public async Task RemoveAsync(SqlQueryEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(SqlQueryEntity entity)
+        public async Task UpdateAsync(SqlQueryEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/UpdatesResourceGroup.cs b/src/Seq.Api/ResourceGroups/UpdatesResourceGroup.cs
index 157adb5..61149aa 100644
--- a/src/Seq.Api/ResourceGroups/UpdatesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/UpdatesResourceGroup.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Updates;
 
@@ -11,9 +12,9 @@ internal UpdatesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<List<AvailableUpdateEntity>> ListAsync()
+        public async Task<List<AvailableUpdateEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<AvailableUpdateEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<AvailableUpdateEntity>("Items", token: token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/UsersResourceGroup.cs b/src/Seq.Api/ResourceGroups/UsersResourceGroup.cs
index aa87ec1..e885083 100644
--- a/src/Seq.Api/ResourceGroups/UsersResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/UsersResourceGroup.cs
@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using Seq.Api.Model.Users;
 using System.Linq;
+using System.Threading;
 using Seq.Api.Client;
 
 namespace Seq.Api.ResourceGroups
@@ -14,69 +15,69 @@ internal UsersResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<UserEntity> FindAsync(string id)
+        public async Task<UserEntity> FindAsync(string id, CancellationToken token = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<UserEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<UserEntity>("Item", new Dictionary<string, object> { { "id", id } }, token).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> FindCurrentAsync()
+        public async Task<UserEntity> FindCurrentAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<UserEntity>("Current").ConfigureAwait(false);
+            return await GroupGetAsync<UserEntity>("Current", token: token).ConfigureAwait(false);
         }
 
-        public async Task<List<UserEntity>> ListAsync()
+        public async Task<List<UserEntity>> ListAsync(CancellationToken token = default)
         {
-            return await GroupListAsync<UserEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<UserEntity>("Items", token: token).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> TemplateAsync()
+        public async Task<UserEntity> TemplateAsync(CancellationToken token = default)
         {
-            return await GroupGetAsync<UserEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<UserEntity>("Template", token: token).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> AddAsync(UserEntity entity)
+        public async Task<UserEntity> AddAsync(UserEntity entity, CancellationToken token = default)
         {
-            return await Client.PostAsync<UserEntity, UserEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<UserEntity, UserEntity>(entity, "Create", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(UserEntity entity)
+        public async Task RemoveAsync(UserEntity entity, CancellationToken token = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(UserEntity entity)
+        public async Task UpdateAsync(UserEntity entity, CancellationToken token = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, token: token).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> LoginAsync(string username, string password)
+        public async Task<UserEntity> LoginAsync(string username, string password, CancellationToken token = default)
         {
             if (username == null) throw new ArgumentNullException(nameof(username));
             if (password == null) throw new ArgumentNullException(nameof(password));
             var credentials = new CredentialsPart {Username = username, Password = password};
-            return await GroupPostAsync<CredentialsPart, UserEntity>("Login", credentials).ConfigureAwait(false);
+            return await GroupPostAsync<CredentialsPart, UserEntity>("Login", credentials, token: token).ConfigureAwait(false);
         }
 
-        public async Task LogoutAsync()
+        public async Task LogoutAsync(CancellationToken token = default)
         {
-            await GroupPostAsync("Logout", new object()).ConfigureAwait(false);
+            await GroupPostAsync("Logout", new object(), token: token).ConfigureAwait(false);
         }
 
-        public async Task<SearchHistoryEntity> GetSearchHistoryAsync(UserEntity entity)
+        public async Task<SearchHistoryEntity> GetSearchHistoryAsync(UserEntity entity, CancellationToken token = default)
         {
-            return await Client.GetAsync<SearchHistoryEntity>(entity, "SearchHistory").ConfigureAwait(false);
+            return await Client.GetAsync<SearchHistoryEntity>(entity, "SearchHistory", token: token).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> LoginWindowsIntegratedAsync()
+        public async Task<UserEntity> LoginWindowsIntegratedAsync(CancellationToken token = default)
         {
-            var providers = await GroupGetAsync<AuthProvidersPart>("AuthenticationProviders").ConfigureAwait(false);
+            var providers = await GroupGetAsync<AuthProvidersPart>("AuthenticationProviders", token: token).ConfigureAwait(false);
             var provider = providers.Providers.SingleOrDefault(p => p.Name == "Integrated Windows Authentication");
             if (provider == null)
                 throw new SeqApiException("The Integrated Windows Authentication provider is not available.", null);
-            var response = await Client.HttpClient.GetAsync(provider.Url).ConfigureAwait(false);
+            var response = await Client.HttpClient.GetAsync(provider.Url, token).ConfigureAwait(false);
             response.EnsureSuccessStatusCode();
-            return await FindCurrentAsync().ConfigureAwait(false);
+            return await FindCurrentAsync(token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/Seq.Api.csproj b/src/Seq.Api/Seq.Api.csproj
index a1dddf3..3c1bd5b 100644
--- a/src/Seq.Api/Seq.Api.csproj
+++ b/src/Seq.Api/Seq.Api.csproj
@@ -4,7 +4,7 @@
     <VersionPrefix>5.0.0</VersionPrefix>
     <Authors>Datalust;Contributors</Authors>
     <TargetFrameworks>netstandard1.3</TargetFrameworks>
-    <NoWarn>$(NoWarn);CS1591</NoWarn>
+    <NoWarn>$(NoWarn);CS1591;CS1573</NoWarn>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>Seq.Api</AssemblyName>
diff --git a/src/Seq.Api/SeqConnection.cs b/src/Seq.Api/SeqConnection.cs
index a70c58b..cf90bde 100644
--- a/src/Seq.Api/SeqConnection.cs
+++ b/src/Seq.Api/SeqConnection.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Client;
 using Seq.Api.Model;
@@ -14,12 +15,12 @@ public class SeqConnection : ISeqConnection
         readonly ConcurrentDictionary<string, Task<ResourceGroup>> _resourceGroups = new ConcurrentDictionary<string, Task<ResourceGroup>>();
         readonly Lazy<Task<RootEntity>> _root;
 
-        public SeqConnection(string serverUrl, string apiKey = null, bool useDefaultCredentials = true)
+        public SeqConnection(string serverUrl, string apiKey = null, bool useDefaultCredentials = true, CancellationToken token = default)
         {
             if (serverUrl == null) throw new ArgumentNullException(nameof(serverUrl));
             _client = new SeqApiClient(serverUrl, apiKey, useDefaultCredentials);
 
-            _root = new Lazy<Task<RootEntity>>(() => _client.GetRootAsync());
+            _root = new Lazy<Task<RootEntity>>(() => _client.GetRootAsync(token));
         }
 
         public ApiKeysResourceGroup ApiKeys => new ApiKeysResourceGroup(this);
@@ -56,14 +57,14 @@ public SeqConnection(string serverUrl, string apiKey = null, bool useDefaultCred
 
         public UsersResourceGroup Users => new UsersResourceGroup(this);
 
-        public async Task<ResourceGroup> LoadResourceGroupAsync(string name)
+        public async Task<ResourceGroup> LoadResourceGroupAsync(string name, CancellationToken token = default)
         {
-            return await _resourceGroups.GetOrAdd(name, ResourceGroupFactory).ConfigureAwait(false);
+            return await _resourceGroups.GetOrAdd(name, s => ResourceGroupFactory(s, token)).ConfigureAwait(false);
         }
 
-        async Task<ResourceGroup> ResourceGroupFactory(string name)
+        async Task<ResourceGroup> ResourceGroupFactory(string name, CancellationToken token = default)
         {
-            return await _client.GetAsync<ResourceGroup>(await _root.Value, name + "Resources").ConfigureAwait(false);
+            return await _client.GetAsync<ResourceGroup>(await _root.Value, name + "Resources", token: token).ConfigureAwait(false);
         }
 
         public SeqApiClient Client => _client;

From 95e0a80719dfc0e462819125aaf4c96f256f9e68 Mon Sep 17 00:00:00 2001
From: Simon Cropp <simon.cropp@gmail.com>
Date: Fri, 20 Apr 2018 22:16:55 +1000
Subject: [PATCH 5/5] remove lazy token

---
 src/Seq.Api/SeqConnection.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Seq.Api/SeqConnection.cs b/src/Seq.Api/SeqConnection.cs
index cf90bde..bd80f1f 100644
--- a/src/Seq.Api/SeqConnection.cs
+++ b/src/Seq.Api/SeqConnection.cs
@@ -15,12 +15,12 @@ public class SeqConnection : ISeqConnection
         readonly ConcurrentDictionary<string, Task<ResourceGroup>> _resourceGroups = new ConcurrentDictionary<string, Task<ResourceGroup>>();
         readonly Lazy<Task<RootEntity>> _root;
 
-        public SeqConnection(string serverUrl, string apiKey = null, bool useDefaultCredentials = true, CancellationToken token = default)
+        public SeqConnection(string serverUrl, string apiKey = null, bool useDefaultCredentials = true)
         {
             if (serverUrl == null) throw new ArgumentNullException(nameof(serverUrl));
             _client = new SeqApiClient(serverUrl, apiKey, useDefaultCredentials);
 
-            _root = new Lazy<Task<RootEntity>>(() => _client.GetRootAsync(token));
+            _root = new Lazy<Task<RootEntity>>(() => _client.GetRootAsync());
         }
 
         public ApiKeysResourceGroup ApiKeys => new ApiKeysResourceGroup(this);