Add support for monitoring for S3 crt client (#3138)

sbera87 · web-flow · commit 16ae4f89277c · 2024-10-09T11:19:49.000-04:00
Add support for monitoring for S3 crt client
diff --git a/generated/src/aws-cpp-sdk-s3-crt/source/S3CrtClient.cpp b/generated/src/aws-cpp-sdk-s3-crt/source/S3CrtClient.cpp
@@ -713,9 +713,24 @@ void S3CrtClient::InitCommonCrtRequestOption(CrtRequestCallbackUserData *userDat
 
 static void CopyObjectRequestShutdownCallback(void *user_data)
 {
+  if(!user_data)
+  {
+    AWS_LOGSTREAM_ERROR("CopyObject", "user data passed is NULL ");
+    return;
+  }
   auto *userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);
+
   // call user callback and release user_data
   S3Crt::Model::CopyObjectOutcome outcome(userData->s3CrtClient->GenerateXmlOutcome(userData->response));
+  //log into monitor 
+  if(!outcome.IsSuccess())
+  {
+    userData->asyncCallerContext->GetMonitorContext().OnRequestFailed(userData->request,userData->response);
+  }
+  else
+  {
+    userData->asyncCallerContext->GetMonitorContext().OnRequestSucceeded(userData->request, userData->response);
+  }
   userData->copyResponseHandler(userData->s3CrtClient, *(reinterpret_cast<const CopyObjectRequest*>(userData->originalRequest)), std::move(outcome), userData->asyncCallerContext);
 
   Aws::Delete(userData);
@@ -782,6 +797,7 @@ void S3CrtClient::CopyObjectAsync(const CopyObjectRequest& request, const CopyOb
   {
     return handler(this, request, CopyObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::INTERNAL_FAILURE, "INTERNAL_FAILURE", "Unable to create s3 meta request", false)), handlerContext);
   }
+  handlerContext->GetMonitorContext().StartMonitorContext(Aws::String{"S3CrtClient"},request.GetServiceRequestName(), userData->request);
   options.shutdown_callback = CopyObjectRequestShutdownCallback;
   options.type = AWS_S3_META_REQUEST_TYPE_COPY_OBJECT;
   struct aws_signing_config_aws signing_config_override = m_s3CrtSigningConfig;
@@ -852,13 +868,13 @@ CopyObjectOutcome S3CrtClient::CopyObject(const CopyObjectRequest& request) cons
     [&]()-> CopyObjectOutcome {
       Aws::Utils::Threading::Semaphore sem(0, 1);
       CopyObjectOutcome res;
-
+      auto handlerContext = Aws::MakeShared<AsyncCallerContext>(ALLOCATION_TAG);
       auto handler = CopyObjectResponseReceivedHandler{[&](const S3CrtClient*, const CopyObjectRequest&, const CopyObjectOutcome& outcome, const std::shared_ptr<const Aws::Client::AsyncCallerContext> &) {
         res = std::move(outcome);
         sem.ReleaseAll();
       }};
 
-      S3CrtClient::CopyObjectAsync(request, handler, nullptr);
+      S3CrtClient::CopyObjectAsync(request, handler, handlerContext);
       sem.WaitOne();
       return res;
     },
@@ -869,9 +885,24 @@ CopyObjectOutcome S3CrtClient::CopyObject(const CopyObjectRequest& request) cons
 
 static void GetObjectRequestShutdownCallback(void *user_data)
 {
+  if(!user_data)
+  {
+    AWS_LOGSTREAM_ERROR("GetObject", "user data passed is NULL ");
+    return;
+  }
   auto *userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);
+
   // call user callback and release user_data
   S3Crt::Model::GetObjectOutcome outcome(userData->s3CrtClient->GenerateStreamOutcome(userData->response));
+  //log into monitor 
+  if(!outcome.IsSuccess())
+  {
+    userData->asyncCallerContext->GetMonitorContext().OnRequestFailed(userData->request,userData->response);
+  }
+  else
+  {
+    userData->asyncCallerContext->GetMonitorContext().OnRequestSucceeded(userData->request, userData->response);
+  }
   userData->getResponseHandler(userData->s3CrtClient, *(reinterpret_cast<const GetObjectRequest*>(userData->originalRequest)), std::move(outcome), userData->asyncCallerContext);
 
   Aws::Delete(userData);
@@ -933,6 +964,7 @@ void S3CrtClient::GetObjectAsync(const GetObjectRequest& request, const GetObjec
   {
     return handler(this, request, GetObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER_VALUE", "Output stream in bad state", false)), handlerContext);
   }
+  handlerContext->GetMonitorContext().StartMonitorContext(Aws::String{"S3CrtClient"},request.GetServiceRequestName(), userData->request);
   options.shutdown_callback = GetObjectRequestShutdownCallback;
   options.type = AWS_S3_META_REQUEST_TYPE_GET_OBJECT;
   struct aws_signing_config_aws signing_config_override = m_s3CrtSigningConfig;
@@ -972,13 +1004,13 @@ GetObjectOutcome S3CrtClient::GetObject(const GetObjectRequest& request) const
     [&]()-> GetObjectOutcome {
       Aws::Utils::Threading::Semaphore sem(0, 1);
       GetObjectOutcome res;
-
+      auto handlerContext = Aws::MakeShared<AsyncCallerContext>(ALLOCATION_TAG);
       auto handler = GetObjectResponseReceivedHandler{[&](const S3CrtClient*, const GetObjectRequest&, GetObjectOutcome outcome, const std::shared_ptr<const Aws::Client::AsyncCallerContext> &) {
         res = std::move(outcome);
         sem.ReleaseAll();
       }};
 
-      S3CrtClient::GetObjectAsync(request, handler, nullptr);
+      S3CrtClient::GetObjectAsync(request, handler, handlerContext);
       sem.WaitOne();
       return res;
     },
@@ -989,9 +1021,24 @@ GetObjectOutcome S3CrtClient::GetObject(const GetObjectRequest& request) const
 
 static void PutObjectRequestShutdownCallback(void *user_data)
 {
+  if(!user_data)
+  {
+    AWS_LOGSTREAM_ERROR("PutObject", "user data passed is NULL ");
+    return;
+  }
   auto *userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);
+
   // call user callback and release user_data
   S3Crt::Model::PutObjectOutcome outcome(userData->s3CrtClient->GenerateXmlOutcome(userData->response));
+  //log into monitor 
+  if(!outcome.IsSuccess())
+  {
+    userData->asyncCallerContext->GetMonitorContext().OnRequestFailed(userData->request,userData->response);
+  }
+  else
+  {
+    userData->asyncCallerContext->GetMonitorContext().OnRequestSucceeded(userData->request, userData->response);
+  }
   userData->putResponseHandler(userData->s3CrtClient, *(reinterpret_cast<const PutObjectRequest*>(userData->originalRequest)), std::move(outcome), userData->asyncCallerContext);
 
   Aws::Delete(userData);
@@ -1057,6 +1104,7 @@ void S3CrtClient::PutObjectAsync(const PutObjectRequest& request, const PutObjec
   {
     return handler(this, request, PutObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER_VALUE", "Input stream in bad state", false)), handlerContext);
   }
+  handlerContext->GetMonitorContext().StartMonitorContext(Aws::String{"S3CrtClient"},request.GetServiceRequestName(), userData->request);
   options.shutdown_callback = PutObjectRequestShutdownCallback;
   options.type = AWS_S3_META_REQUEST_TYPE_PUT_OBJECT;
   struct aws_signing_config_aws signing_config_override = m_s3CrtSigningConfig;
@@ -1127,13 +1175,13 @@ PutObjectOutcome S3CrtClient::PutObject(const PutObjectRequest& request) const
     [&]()-> PutObjectOutcome {
       Aws::Utils::Threading::Semaphore sem(0, 1);
       PutObjectOutcome res;
-
+      auto handlerContext = Aws::MakeShared<AsyncCallerContext>(ALLOCATION_TAG);
       auto handler = PutObjectResponseReceivedHandler{[&](const S3CrtClient*, const PutObjectRequest&, const PutObjectOutcome& outcome, const std::shared_ptr<const Aws::Client::AsyncCallerContext> &) {
         res = std::move(outcome);
         sem.ReleaseAll();
       }};
 
-      S3CrtClient::PutObjectAsync(request, handler, nullptr);
+      S3CrtClient::PutObjectAsync(request, handler, handlerContext);
       sem.WaitOne();
       return res;
     },
diff --git a/src/aws-cpp-sdk-core/include/aws/core/client/AsyncCallerContext.h b/src/aws-cpp-sdk-core/include/aws/core/client/AsyncCallerContext.h
@@ -7,10 +7,106 @@
 
 #include <aws/core/utils/memory/stl/AWSString.h>
 
+#include <aws/crt/http/HttpRequestResponse.h>
+#include <aws/core/monitoring/MonitoringManager.h>
+
 namespace Aws
 {
     namespace Client
     {
+
+        class AWS_CORE_API MonitorContext{
+
+            private:
+            mutable Aws::String clientName;
+            mutable Aws::String requestName;
+            mutable Aws::Vector<void*> contexts;
+
+            public:
+            ~MonitorContext() = default;
+            MonitorContext() = default;
+            MonitorContext(const MonitorContext&) = delete;
+            MonitorContext( MonitorContext &&) = delete;
+            MonitorContext& operator=(const MonitorContext&) = delete;
+            MonitorContext& operator=(MonitorContext&&) = delete;
+
+            void StartMonitorContext(const Aws::String& client, const Aws::String& request, std::shared_ptr<Aws::Http::HttpRequest>& httpRequest) const
+            {
+                clientName = client;
+                requestName = request;
+                contexts = Aws::Monitoring::OnRequestStarted(clientName, requestName, httpRequest);
+            }
+
+            inline void OnRequestFailed(std::shared_ptr<Aws::Http::HttpRequest>& httpRequest, const Aws::Client::HttpResponseOutcome& outcome) const
+            {
+                if(!httpRequest)
+                {
+                    return;
+                }
+                Aws::Monitoring::CoreMetricsCollection coreMetrics;
+                coreMetrics.httpClientMetrics = httpRequest->GetRequestMetrics();
+                
+                Aws::Monitoring::OnRequestFailed(
+                clientName,
+                requestName, 
+                httpRequest ,
+                outcome, 
+                coreMetrics, 
+                contexts);
+                
+            }
+
+            inline void OnRequestSucceeded(std::shared_ptr<Aws::Http::HttpRequest> httpRequest, const Aws::Client::HttpResponseOutcome& outcome) const
+            {
+
+                if(!httpRequest)
+                {
+                    return;
+                }
+                
+                Aws::Monitoring::CoreMetricsCollection coreMetrics;
+                coreMetrics.httpClientMetrics = httpRequest->GetRequestMetrics();
+                
+                Aws::Monitoring::OnRequestSucceeded(
+                clientName,
+                requestName, 
+                httpRequest ,
+                outcome, 
+                coreMetrics, 
+                contexts);
+            }
+
+            inline void OnRetry(std::shared_ptr<Aws::Http::HttpRequest> httpRequest) const
+            {
+                if(!httpRequest)
+                {
+                    return;
+                }
+                Aws::Monitoring::CoreMetricsCollection coreMetrics;
+                coreMetrics.httpClientMetrics = httpRequest->GetRequestMetrics();
+                
+                Aws::Monitoring::OnRequestRetry(
+                clientName, 
+                requestName,
+                httpRequest, 
+                contexts);
+            }
+
+            inline void OnFinish(std::shared_ptr<Aws::Http::HttpRequest> httpRequest) const
+            {
+                if(!httpRequest)
+                {
+                    return;
+                }
+                Aws::Monitoring::OnFinish(
+                clientName,
+                requestName, 
+                httpRequest ,
+                contexts);
+            }
+
+        };
+
         /**
         * Call-back context for all async client methods. This allows you to pass a context to your callbacks so that you can identify your requests.
         * It is entirely intended that you override this class in-lieu of using a void* for the user context. The base class just gives you the ability to
@@ -19,6 +115,7 @@ namespace Aws
         class AWS_CORE_API AsyncCallerContext
         {
         public:
+
             /**
              * Initializes object with generated UUID
              */
@@ -27,7 +124,7 @@ namespace Aws
             /**
              * Initializes object with UUID
              */
-            AsyncCallerContext(const Aws::String& uuid) : m_uuid(uuid) {}
+            AsyncCallerContext(const Aws::String& uuid) : m_uuid(uuid){}
 
             /**
             * Initializes object with UUID
@@ -51,8 +148,13 @@ namespace Aws
              */
             inline void SetUUID(const char* value) { m_uuid.assign(value); }
 
+            inline const MonitorContext& GetMonitorContext() const{
+                return monitorContext;
+            }
+
         private:
             Aws::String m_uuid;
+            mutable MonitorContext monitorContext;
         };
     }
 }
diff --git a/src/aws-cpp-sdk-core/include/aws/core/monitoring/MonitoringManager.h b/src/aws-cpp-sdk-core/include/aws/core/monitoring/MonitoringManager.h
@@ -61,5 +61,11 @@ namespace Aws
          * testing whether the global Monitoring instance has been destructed.
          */
         AWS_CORE_API void CleanupMonitoring();
+
+        /**
+         * Add monitoring using supplied factories
+         */
+        AWS_CORE_API void AddMonitoring(const std::vector<MonitoringFactoryCreateFunction>& monitoringFactoryCreateFunctions);
+
     }
 }
diff --git a/src/aws-cpp-sdk-core/source/monitoring/MonitoringManager.cpp b/src/aws-cpp-sdk-core/source/monitoring/MonitoringManager.cpp
@@ -97,26 +97,37 @@ namespace Aws
             }
         }
 
+        void AddMonitoring(const std::vector<MonitoringFactoryCreateFunction>& monitoringFactoryCreateFunctions)
+        {
+            //allocate monitors only if there are valid factory functions
+            if(s_monitors && !monitoringFactoryCreateFunctions.empty())
+            {
+                for (const auto& function: monitoringFactoryCreateFunctions)
+                {
+                    auto factory = function();
+                    if (factory)
+                    {
+                        auto instance = factory->CreateMonitoringInstance();
+                        if (instance)
+                        {
+                            s_monitors->emplace_back(std::move(instance));
+                        }
+                    }
+                }
+            }
+        }
+
+
         void InitMonitoring(const std::vector<MonitoringFactoryCreateFunction>& monitoringFactoryCreateFunctions)
         {
             if (s_monitors)
             {
                 return;
             }
             assert(Aws::get_aws_allocator() != nullptr);
+
             s_monitors = Aws::New<Monitors>(MonitoringTag);
-            for (const auto& function: monitoringFactoryCreateFunctions)
-            {
-                auto factory = function();
-                if (factory)
-                {
-                    auto instance = factory->CreateMonitoringInstance();
-                    if (instance)
-                    {
-                        s_monitors->emplace_back(std::move(instance));
-                    }
-                }
-            }
+            AddMonitoring(monitoringFactoryCreateFunctions);
 
             auto defaultMonitoringFactory = Aws::MakeShared<DefaultMonitoringFactory>(MonitoringTag);
             auto instance = defaultMonitoringFactory->CreateMonitoringInstance();
@@ -128,8 +139,11 @@ namespace Aws
 
         void CleanupMonitoring()
         {
-            Aws::Delete(s_monitors);
-            s_monitors = nullptr;
+            if(s_monitors)
+            {
+                Aws::Delete(s_monitors);
+                s_monitors = nullptr;
+            }
         }
     } // namespace Monitoring
 
diff --git a/tests/aws-cpp-sdk-s3-crt-integration-tests/BucketAndObjectOperationTest.cpp b/tests/aws-cpp-sdk-s3-crt-integration-tests/BucketAndObjectOperationTest.cpp
diff --git a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/s3/s3-crt/S3CrtSpecificOperations.vm b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/s3/s3-crt/S3CrtSpecificOperations.vm

Original file line number	Diff line number	Diff line change
`@@ -61,5 +61,11 @@ namespace Aws`
`61`	`61`	`* testing whether the global Monitoring instance has been destructed.`
`62`	`62`	`*/`
`63`	`63`	`AWS_CORE_API void CleanupMonitoring();`
	`64`	`+`
	`65`	`+ /**`
	`66`	`+ * Add monitoring using supplied factories`
	`67`	`+ */`
	`68`	`+ AWS_CORE_API void AddMonitoring(const std::vector<MonitoringFactoryCreateFunction>& monitoringFactoryCreateFunctions);`
	`69`	`+`
`64`	`70`	`}`
`65`	`71`	`}`