feat: Add IApiToolkitClientFactory interface and implementation

- Added IApiToolkitClientFactory interface to provide an abstraction for creating HttpClient instances with specific ATOptions.
- Implemented ApiToolkitClientFactory class, which leverages HttpClientFactory for centralized management of HttpClient instances.

Author: shepherrrd

ApiToolKit.cs

@@ -9,6 +9,7 @@
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json;
 using System.Diagnostics;
+using Microsoft.Extensions.DependencyInjection;
 using System.Text.Json;
 using static System.Web.HttpUtility;
 
@@ -424,6 +425,31 @@ public class ATError
     public string StackTrace { get; set; }
   }
 
+public interface IApiToolkitClientFactory
+{
+    HttpClient CreateClient(ATOptions options);
+}
+
+public class ApiToolkitClientFactory : IApiToolkitClientFactory
+{
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly IServiceProvider _serviceProvider;
+
+    public ApiToolkitClientFactory(IHttpClientFactory httpClientFactory, IServiceProvider serviceProvider)
+    {
+        _httpClientFactory = httpClientFactory;
+        _serviceProvider = serviceProvider;
+    }
+
+    public HttpClient CreateClient(ATOptions options)
+    {
+        var client = _httpClientFactory.CreateClient();
+        
+        var handler = _serviceProvider.GetRequiredService<ObservingHandler>();
+        handler.SetOptions(options);
+        return new HttpClient(handler);
+    }
+}
 
   public class ATOptions
   {
@@ -436,9 +462,13 @@ public class ObservingHandler : DelegatingHandler
   {
     private readonly HttpContext _context;
     private readonly Func<Payload, Task> _publishMessageAsync;
-    private readonly ATOptions _options;
+    private  ATOptions _options;
     private readonly string _project_id;
     private readonly string? _msg_id;
+     public void SetOptions(ATOptions options)
+    {
+        _options = options;
+    }
     public ObservingHandler(Func<Payload, Task> publishMessage, string project_id, HttpContext? httpContext = null, ATOptions? options = null) : base(new HttpClientHandler())
     {
       _context = httpContext ?? throw new ArgumentNullException(nameof(httpContext));

README.md

@@ -38,6 +38,11 @@ Next, initialize APItoolkit in your application's entry point (e.g., `Program.cs
 using ApiToolkit.Net;
 
 // Initialize the APItoolkit client
+builder.Services.AddTransient<ObservingHandler>();
+
+// Register the custom API Toolkit Client Factory
+builder.Services.AddSingleton<IApiToolkitClientFactory, ApiToolkitClientFactory>();
+
 var config = new Config
 {
     ApiKey = "{ENTER_YOUR_API_KEY_HERE}",
@@ -60,6 +65,66 @@ app.Use(async (context, next) =>
 # ...
 ```
 
+## Usage
+
+You can now use the IApiToolKitClientFactory Interface to directly make your Http requests
+
+```csharp
+public class MyService
+{
+    private readonly IApiToolkitClientFactory _apiToolkitClientFactory;
+
+    public MyService(IApiToolkitClientFactory apiToolkitClientFactory)
+    {
+        _apiToolkitClientFactory = apiToolkitClientFactory;
+    }
+
+    public async Task<string> GetPostAsync()
+    {
+        var options = new ATOptions
+        {
+            PathWildCard = "/posts/{id}",
+            RedactHeaders = new[] { "User-Agent" },
+            RedactRequestBody = new[] { "$.user.password" },
+            RedactResponseBody = new[] { "$.user.data.email" }
+        };
+
+        var client = _apiToolkitClientFactory.CreateClient(options);
+        var response = await client.GetAsync("https://jsonplaceholder.typicode.com/posts/1");
+        return await response.Content.ReadAsStringAsync();
+    }
+}
+```
+
+Traditional Middleware Setup
+If you prefer to set up the middleware traditionally, here's how you can initialize APItoolkit in your application's entry point (e.g., Program.cs):
+
+```csharp
+using ApiToolkit.Net;
+
+// Initialize the APItoolkit client
+var config = new Config
+{
+    ApiKey = "{ENTER_YOUR_API_KEY_HERE}",
+    Debug = false,
+    Tags = new List<string> { "environment: production", "region: us-east-1" },
+    ServiceVersion: "v2.0",
+};
+var client = await APIToolkit.NewClientAsync(config);
+
+// Register the middleware to use the initialized client
+app.Use(async (context, next) =>
+{
+    var apiToolkit = new APIToolkit(next, client);
+    await apiToolkit.InvokeAsync(context);
+});
+
+// app.UseEndpoint(..)
+// other middleware and logic
+// ...
+```
+
+
 > [!NOTE]
 > 
 > - Please make sure the APItoolkit middleware is added before `UseEndpoint` and other middleware are initialized.