[EXPORTER] OTLP file: use fopen, fwrite, fflush and fclose wh…

…ich are thread-safe. (#2675)

* Use `fopen`, `fwrite`, `fflush` and `fclose` which are thread-safety.

* Add some macros to help to find problems.

Add `OPENTELEMETRY_ATTRIBUTE_LIFETIME_BOUND` , `OPENTELEMETRY_SANITIZER_NO_MEMORY` , `OPENTELEMETRY_SANITIZER_NO_THREAD`, `OPENTELEMETRY_SANITIZER_NO_ADDRESS`, `OPENTELEMETRY_HAVE_BUILTIN`, `OPENTELEMETRY_HAVE_FEATURE`, `OPENTELEMETRY_HAVE_ATTRIBUTE`, `OPENTELEMETRY_HAVE_CPP_ATTRIBUTE`

* Append EOL before call Export of backend

---------

Co-authored-by: Marc Alff <[email protected]>

api/include/opentelemetry/common/macros.h

@@ -3,6 +3,73 @@
 
 #pragma once
 
+/*
+   OPENTELEMETRY_HAVE_BUILTIN&OPENTELEMETRY_HAVE_FEATURE
+
+   Checks whether the compiler supports a Clang Feature Checking Macro, and if
+   so, checks whether it supports the provided builtin function "x" where x
+   is one of the functions noted in
+   https://clang.llvm.org/docs/LanguageExtensions.html
+
+   Note: Use this macro to avoid an extra level of #ifdef __has_builtin check.
+   http://releases.llvm.org/3.3/tools/clang/docs/LanguageExtensions.html
+*/
+#if !defined(OPENTELEMETRY_HAVE_BUILTIN)
+#  ifdef __has_builtin
+#    define OPENTELEMETRY_HAVE_BUILTIN(x) __has_builtin(x)
+#  else
+#    define OPENTELEMETRY_HAVE_BUILTIN(x) 0
+#  endif
+#endif
+
+#if !defined(OPENTELEMETRY_HAVE_FEATURE)
+#  ifdef __has_feature
+#    define OPENTELEMETRY_HAVE_FEATURE(f) __has_feature(f)
+#  else
+#    define OPENTELEMETRY_HAVE_FEATURE(f) 0
+#  endif
+#endif
+
+/*
+   has feature
+
+   OPENTELEMETRY_HAVE_ATTRIBUTE
+
+   A function-like feature checking macro that is a wrapper around
+   `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
+   nonzero constant integer if the attribute is supported or 0 if not.
+
+   It evaluates to zero if `__has_attribute` is not defined by the compiler.
+
+   GCC: https://gcc.gnu.org/gcc-5/changes.html
+   Clang: https://clang.llvm.org/docs/LanguageExtensions.html
+*/
+#if !defined(OPENTELEMETRY_HAVE_ATTRIBUTE)
+#  ifdef __has_attribute
+#    define OPENTELEMETRY_HAVE_ATTRIBUTE(x) __has_attribute(x)
+#  else
+#    define OPENTELEMETRY_HAVE_ATTRIBUTE(x) 0
+#  endif
+#endif
+
+/*
+   OPENTELEMETRY_HAVE_CPP_ATTRIBUTE
+
+   A function-like feature checking macro that accepts C++11 style attributes.
+   It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
+   (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
+   find `__has_cpp_attribute`, will evaluate to 0.
+*/
+#if !defined(OPENTELEMETRY_HAVE_CPP_ATTRIBUTE)
+#  if defined(__cplusplus) && defined(__has_cpp_attribute)
+// NOTE: requiring __cplusplus above should not be necessary, but
+// works around https://bugs.llvm.org/show_bug.cgi?id=23435.
+#    define OPENTELEMETRY_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#  else
+#    define OPENTELEMETRY_HAVE_CPP_ATTRIBUTE(x) 0
+#  endif
+#endif
+
 /*
    Expected usage pattern:
 
@@ -319,3 +386,107 @@ point.
 #  define OPENTELEMETRY_EXPORT
 
 #endif
+
+/*
+   OPENTELEMETRY_ATTRIBUTE_LIFETIME_BOUND indicates that a resource owned by a function
+   parameter or implicit object parameter is retained by the return value of the
+   annotated function (or, for a parameter of a constructor, in the value of the
+   constructed object). This attribute causes warnings to be produced if a
+   temporary object does not live long enough.
+
+   When applied to a reference parameter, the referenced object is assumed to be
+   retained by the return value of the function. When applied to a non-reference
+   parameter (for example, a pointer or a class type), all temporaries
+   referenced by the parameter are assumed to be retained by the return value of
+   the function.
+
+   See also the upstream documentation:
+   https://clang.llvm.org/docs/AttributeReference.html#lifetimebound
+*/
+#ifndef OPENTELEMETRY_ATTRIBUTE_LIFETIME_BOUND
+#  if OPENTELEMETRY_HAVE_CPP_ATTRIBUTE(clang::lifetimebound)
+#    define OPENTELEMETRY_ATTRIBUTE_LIFETIME_BOUND [[clang::lifetimebound]]
+#  elif OPENTELEMETRY_HAVE_ATTRIBUTE(lifetimebound)
+#    define OPENTELEMETRY_ATTRIBUTE_LIFETIME_BOUND __attribute__((lifetimebound))
+#  else
+#    define OPENTELEMETRY_ATTRIBUTE_LIFETIME_BOUND
+#  endif
+#endif
+
+// OPENTELEMETRY_HAVE_MEMORY_SANITIZER
+//
+// MemorySanitizer (MSan) is a detector of uninitialized reads. It consists of
+// a compiler instrumentation module and a run-time library.
+#ifndef OPENTELEMETRY_HAVE_MEMORY_SANITIZER
+#  if !defined(__native_client__) && OPENTELEMETRY_HAVE_FEATURE(memory_sanitizer)
+#    define OPENTELEMETRY_HAVE_MEMORY_SANITIZER 1
+#  else
+#    define OPENTELEMETRY_HAVE_MEMORY_SANITIZER 0
+#  endif
+#endif
+
+#if OPENTELEMETRY_HAVE_MEMORY_SANITIZER && OPENTELEMETRY_HAVE_ATTRIBUTE(no_sanitize_memory)
+#  define OPENTELEMETRY_SANITIZER_NO_MEMORY \
+    __attribute__((no_sanitize_memory))  // __attribute__((no_sanitize("memory")))
+#else
+#  define OPENTELEMETRY_SANITIZER_NO_MEMORY
+#endif
+
+// OPENTELEMETRY_HAVE_THREAD_SANITIZER
+//
+// ThreadSanitizer (TSan) is a fast data race detector.
+#ifndef OPENTELEMETRY_HAVE_THREAD_SANITIZER
+#  if defined(__SANITIZE_THREAD__)
+#    define OPENTELEMETRY_HAVE_THREAD_SANITIZER 1
+#  elif OPENTELEMETRY_HAVE_FEATURE(thread_sanitizer)
+#    define OPENTELEMETRY_HAVE_THREAD_SANITIZER 1
+#  else
+#    define OPENTELEMETRY_HAVE_THREAD_SANITIZER 0
+#  endif
+#endif
+
+#if OPENTELEMETRY_HAVE_THREAD_SANITIZER && OPENTELEMETRY_HAVE_ATTRIBUTE(no_sanitize_thread)
+#  define OPENTELEMETRY_SANITIZER_NO_THREAD \
+    __attribute__((no_sanitize_thread))  // __attribute__((no_sanitize("thread")))
+#else
+#  define OPENTELEMETRY_SANITIZER_NO_THREAD
+#endif
+
+// OPENTELEMETRY_HAVE_ADDRESS_SANITIZER
+//
+// AddressSanitizer (ASan) is a fast memory error detector.
+#ifndef OPENTELEMETRY_HAVE_ADDRESS_SANITIZER
+#  if defined(__SANITIZE_ADDRESS__)
+#    define OPENTELEMETRY_HAVE_ADDRESS_SANITIZER 1
+#  elif OPENTELEMETRY_HAVE_FEATURE(address_sanitizer)
+#    define OPENTELEMETRY_HAVE_ADDRESS_SANITIZER 1
+#  else
+#    define OPENTELEMETRY_HAVE_ADDRESS_SANITIZER 0
+#  endif
+#endif
+
+// OPENTELEMETRY_HAVE_HWADDRESS_SANITIZER
+//
+// Hardware-Assisted AddressSanitizer (or HWASAN) is even faster than asan
+// memory error detector which can use CPU features like ARM TBI, Intel LAM or
+// AMD UAI.
+#ifndef OPENTELEMETRY_HAVE_HWADDRESS_SANITIZER
+#  if defined(__SANITIZE_HWADDRESS__)
+#    define OPENTELEMETRY_HAVE_HWADDRESS_SANITIZER 1
+#  elif OPENTELEMETRY_HAVE_FEATURE(hwaddress_sanitizer)
+#    define OPENTELEMETRY_HAVE_HWADDRESS_SANITIZER 1
+#  else
+#    define OPENTELEMETRY_HAVE_HWADDRESS_SANITIZER 0
+#  endif
+#endif
+
+#if OPENTELEMETRY_HAVE_ADDRESS_SANITIZER && OPENTELEMETRY_HAVE_ATTRIBUTE(no_sanitize_address)
+#  define OPENTELEMETRY_SANITIZER_NO_ADDRESS \
+    __attribute__((no_sanitize_address))  // __attribute__((no_sanitize("address")))
+#elif OPENTELEMETRY_HAVE_ADDRESS_SANITIZER && defined(_MSC_VER) && _MSC_VER >= 1928
+#  define OPENTELEMETRY_SANITIZER_NO_ADDRESS __declspec(no_sanitize_address)
+#elif OPENTELEMETRY_HAVE_HWADDRESS_SANITIZER && OPENTELEMETRY_HAVE_ATTRIBUTE(no_sanitize)
+#  define OPENTELEMETRY_SANITIZER_NO_ADDRESS __attribute__((no_sanitize("hwaddress")))
+#else
+#  define OPENTELEMETRY_SANITIZER_NO_ADDRESS
+#endif

api/include/opentelemetry/nostd/string_view.h

@@ -18,6 +18,7 @@
 #  include <stdexcept>
 #  include <string>
 
+#  include "opentelemetry/common/macros.h"
 #  include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
@@ -43,7 +44,7 @@ class string_view
 
   string_view(const char *str) noexcept : length_(std::strlen(str)), data_(str) {}
 
-  string_view(const std::basic_string<char> &str) noexcept
+  string_view(const std::basic_string<char> &str OPENTELEMETRY_ATTRIBUTE_LIFETIME_BOUND) noexcept
       : length_(str.length()), data_(str.c_str())
   {}