Add logger flush API

marcomagdy · web-flow · commit 4d92ec7ab6da · 2019-05-30T16:21:13.000-07:00
In execution environments like AWS Lambda, especially short lived
functions, the logs do not get flushed fast enough. This is more
prominent if the Lambda invocations are small and do not accumulate
enough messages to trigger automatic flushing.
diff --git a/aws-cpp-sdk-core-tests/utils/logging/LoggingTest.cpp b/aws-cpp-sdk-core-tests/utils/logging/LoggingTest.cpp
@@ -64,6 +64,9 @@ void LogAllPossibilities(const char* tag)
     AWS_LOG_TRACE(tag, "test trace level");
     AWS_LOG_TRACE(tag, "test %s format level", "trace");
     AWS_LOGSTREAM_TRACE(tag, "test " << "trace " << "stream level" );
+
+    AWS_LOG_FLUSH();
+    AWS_LOGSTREAM_FLUSH();
 }
 
 void VerifyAllLogsAtOrBelow(LogLevel logLevel, const Aws::String& tag, const Aws::Vector<Aws::String>& loggedStatements)
diff --git a/aws-cpp-sdk-core/include/aws/core/utils/logging/ConsoleLogSystem.h b/aws-cpp-sdk-core/include/aws/core/utils/logging/ConsoleLogSystem.h
@@ -40,6 +40,11 @@ namespace Aws
 
                 virtual ~ConsoleLogSystem() {}
 
+                /**
+                 * Flushes buffered messages to stdout.
+                 */
+                void Flush() override;
+
             protected:
 
                 virtual void ProcessFormattedStatement(Aws::String&& statement) override;
diff --git a/aws-cpp-sdk-core/include/aws/core/utils/logging/DefaultLogSystem.h b/aws-cpp-sdk-core/include/aws/core/utils/logging/DefaultLogSystem.h
@@ -53,8 +53,15 @@ namespace Aws
                  * on construction.
                  */
                 DefaultLogSystem(LogLevel logLevel, const Aws::String& filenamePrefix);
+
                 virtual ~DefaultLogSystem();
 
+                /**
+                 * Flushes buffered messages to the file system.
+                 * This method is thread-safe.
+                 */
+                void Flush() override;
+
                 /**
                  * Structure containing semaphores, queue etc... 
                  */
@@ -66,7 +73,7 @@ namespace Aws
                     std::mutex m_logQueueMutex;
                     std::condition_variable m_queueSignal;
                     Aws::Vector<Aws::String> m_queuedLogMessages;
-                    std::atomic<bool> m_stopLogging;
+                    bool m_stopLogging;
 
                 private:
                     LogSynchronizationData(const LogSynchronizationData& rhs) = delete;
diff --git a/aws-cpp-sdk-core/include/aws/core/utils/logging/LogMacros.h b/aws-cpp-sdk-core/include/aws/core/utils/logging/LogMacros.h
@@ -37,6 +37,7 @@
     #define AWS_LOG_INFO(tag, ...) 
     #define AWS_LOG_DEBUG(tag, ...) 
     #define AWS_LOG_TRACE(tag, ...) 
+    #define AWS_LOG_FLUSH()
 
     #define AWS_LOGSTREAM(level, tag, streamExpression) 
     #define AWS_LOGSTREAM_FATAL(tag, streamExpression)
@@ -45,9 +46,19 @@
     #define AWS_LOGSTREAM_INFO(tag, streamExpression)
     #define AWS_LOGSTREAM_DEBUG(tag, streamExpression)
     #define AWS_LOGSTREAM_TRACE(tag, streamExpression)
+    #define AWS_LOGSTREAM_FLUSH()
 
 #else
 
+    #define AWS_LOG_FLUSH() \
+        { \
+            Aws::Utils::Logging::LogSystemInterface* logSystem = Aws::Utils::Logging::GetLogSystem(); \
+            if ( logSystem ) \
+            { \
+                logSystem->Flush(); \
+            } \
+        }
+
     #define AWS_LOG(level, tag, ...) \
         { \
             Aws::Utils::Logging::LogSystemInterface* logSystem = Aws::Utils::Logging::GetLogSystem(); \
@@ -188,4 +199,6 @@
             } \
         }
 
+    #define AWS_LOGSTREAM_FLUSH()  AWS_LOG_FLUSH()
+
 #endif // DISABLE_AWS_LOGGING
diff --git a/aws-cpp-sdk-core/include/aws/core/utils/logging/LogSystemInterface.h b/aws-cpp-sdk-core/include/aws/core/utils/logging/LogSystemInterface.h
@@ -50,7 +50,10 @@ namespace Aws
                 * Writes the stream to the output stream.
                 */
                 virtual void LogStream(LogLevel logLevel, const char* tag, const Aws::OStringStream &messageStream) = 0;
-
+                /**
+                 * Writes any buffered messages to the underlying device if the logger supports buffering.
+                 */
+                virtual void Flush() = 0;
             };
 
         } // namespace Logging
diff --git a/aws-cpp-sdk-core/include/aws/core/utils/logging/android/LogcatLogSystem.h b/aws-cpp-sdk-core/include/aws/core/utils/logging/android/LogcatLogSystem.h
@@ -32,12 +32,12 @@ class AWS_CORE_API LogcatLogSystem : public FormattedLogSystem
 
         using Base = FormattedLogSystem;
 
-        LogcatLogSystem(LogLevel logLevel) :
-	    Base(logLevel)
-	{}
+        LogcatLogSystem(LogLevel logLevel) : Base(logLevel) {}
 
         virtual ~LogcatLogSystem() {}
 
+        void Flush() override { /* no-op android NDK does not have a flush api */ }
+
     protected:
 
 	virtual void ProcessFormattedStatement(Aws::String&& statement) override;
diff --git a/aws-cpp-sdk-core/source/utils/logging/ConsoleLogSystem.cpp b/aws-cpp-sdk-core/source/utils/logging/ConsoleLogSystem.cpp
@@ -25,3 +25,8 @@ void ConsoleLogSystem::ProcessFormattedStatement(Aws::String&& statement)
 {
     std::cout << statement;
 }
+
+void ConsoleLogSystem::Flush()
+{
+    std::cout.flush();
+}
diff --git a/aws-cpp-sdk-core/source/utils/logging/DefaultLogSystem.cpp b/aws-cpp-sdk-core/source/utils/logging/DefaultLogSystem.cpp
@@ -42,7 +42,7 @@ static void LogThread(DefaultLogSystem::LogSynchronizationData* syncData, const
     for(;;)
     {
         std::unique_lock<std::mutex> locker(syncData->m_logQueueMutex);
-        syncData->m_queueSignal.wait(locker, [&](){ return syncData->m_stopLogging.load() == true || syncData->m_queuedLogMessages.size() > 0; } );
+        syncData->m_queueSignal.wait(locker, [&](){ return syncData->m_stopLogging == true || syncData->m_queuedLogMessages.size() > 0; } );
 
         if (syncData->m_stopLogging && syncData->m_queuedLogMessages.size() == 0)
         {
@@ -97,7 +97,7 @@ DefaultLogSystem::~DefaultLogSystem()
 {
     {
         std::lock_guard<std::mutex> locker(m_syncData.m_logQueueMutex);
-        m_syncData.m_stopLogging.store(true);
+        m_syncData.m_stopLogging = true;
     }
 
     m_syncData.m_queueSignal.notify_one();
@@ -120,3 +120,8 @@ void DefaultLogSystem::ProcessFormattedStatement(Aws::String&& statement)
     }
 }
 
+void DefaultLogSystem::Flush()
+{
+    m_syncData.m_queueSignal.notify_one();
+}
+

Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,9 @@ void LogAllPossibilities(const char* tag)`
`64`	`64`	`AWS_LOG_TRACE(tag, "test trace level");`
`65`	`65`	`AWS_LOG_TRACE(tag, "test %s format level", "trace");`
`66`	`66`	`AWS_LOGSTREAM_TRACE(tag, "test " << "trace " << "stream level" );`
	`67`	`+`
	`68`	`+ AWS_LOG_FLUSH();`
	`69`	`+ AWS_LOGSTREAM_FLUSH();`
`67`	`70`	`}`
`68`	`71`
`69`	`72`	`void VerifyAllLogsAtOrBelow(LogLevel logLevel, const Aws::String& tag, const Aws::Vector<Aws::String>& loggedStatements)`
Original file line number	Diff line number	Diff line change
`@@ -25,3 +25,8 @@ void ConsoleLogSystem::ProcessFormattedStatement(Aws::String&& statement)`
`25`	`25`	`{`
`26`	`26`	`std::cout << statement;`
`27`	`27`	`}`
	`28`	`+`
	`29`	`+void ConsoleLogSystem::Flush()`
	`30`	`+{`
	`31`	`+ std::cout.flush();`
	`32`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ static void LogThread(DefaultLogSystem::LogSynchronizationData* syncData, const`
`42`	`42`	`for(;;)`
`43`	`43`	`{`
`44`	`44`	`std::unique_lock<std::mutex> locker(syncData->m_logQueueMutex);`
`45`		`- syncData->m_queueSignal.wait(locker, [&](){ return syncData->m_stopLogging.load() == true \|\| syncData->m_queuedLogMessages.size() > 0; } );`
	`45`	`+ syncData->m_queueSignal.wait(locker, [&](){ return syncData->m_stopLogging == true \|\| syncData->m_queuedLogMessages.size() > 0; } );`
`46`	`46`
`47`	`47`	`if (syncData->m_stopLogging && syncData->m_queuedLogMessages.size() == 0)`
`48`	`48`	`{`
`@@ -97,7 +97,7 @@ DefaultLogSystem::~DefaultLogSystem()`
`97`	`97`	`{`
`98`	`98`	`{`
`99`	`99`	`std::lock_guard<std::mutex> locker(m_syncData.m_logQueueMutex);`
`100`		`- m_syncData.m_stopLogging.store(true);`
	`100`	`+ m_syncData.m_stopLogging = true;`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`m_syncData.m_queueSignal.notify_one();`
`@@ -120,3 +120,8 @@ void DefaultLogSystem::ProcessFormattedStatement(Aws::String&& statement)`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`
	`123`	`+void DefaultLogSystem::Flush()`
	`124`	`+{`
	`125`	`+ m_syncData.m_queueSignal.notify_one();`
	`126`	`+}`
	`127`	`+`