[BUILD] Remove defining NOMINMAX from api

api/CMakeLists.txt

@@ -104,7 +104,6 @@ if(WITH_NO_GETENV)
 endif()
 
 if(WIN32)
-  target_compile_definitions(opentelemetry_api INTERFACE NOMINMAX)
   if(WITH_ETW)
     target_compile_definitions(opentelemetry_api INTERFACE HAVE_MSGPACK)
   endif()

api/include/opentelemetry/common/spin_lock_mutex.h

@@ -10,9 +10,6 @@
 #include "opentelemetry/version.h"
 
 #if defined(_MSC_VER)
-#  ifndef NOMINMAX
-#    define NOMINMAX
-#  endif
 #  define _WINSOCKAPI_  // stops including winsock.h
 #  include <windows.h>
 #elif defined(__i386__) || defined(__x86_64__)

api/include/opentelemetry/common/timestamp.h

@@ -178,21 +178,21 @@ class DurationUtil
       std::chrono::duration<Rep, Period> indefinite_value) noexcept
   {
     // Do not call now() when this duration is max value, now() may have a expensive cost.
-    if (timeout == std::chrono::duration<Rep, Period>::max())
+    if (timeout == (std::chrono::duration<Rep, Period>::max)())
     {
       return indefinite_value;
     }
 
     // std::future<T>::wait_for, std::this_thread::sleep_for, and std::condition_variable::wait_for
     // may use steady_clock or system_clock.We need make sure now() + timeout do not overflow.
     auto max_timeout = std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(
-        std::chrono::steady_clock::time_point::max() - std::chrono::steady_clock::now());
+        (std::chrono::steady_clock::time_point::max)() - std::chrono::steady_clock::now());
     if (timeout >= max_timeout)
     {
       return indefinite_value;
     }
     max_timeout = std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(
-        std::chrono::system_clock::time_point::max() - std::chrono::system_clock::now());
+        (std::chrono::system_clock::time_point::max)() - std::chrono::system_clock::now());
     if (timeout >= max_timeout)
     {
       return indefinite_value;

api/include/opentelemetry/plugin/detail/dynamic_load_windows.h

@@ -12,9 +12,6 @@
 #include "opentelemetry/plugin/hook.h"
 #include "opentelemetry/version.h"
 
-#ifndef NOMINMAX
-#  define NOMINMAX
-#endif
 #include <Windows.h>
 
 #include <WinBase.h>

exporters/ostream/include/opentelemetry/exporters/ostream/log_record_exporter.h

@@ -47,13 +47,13 @@ class OStreamLogRecordExporter final : public opentelemetry::sdk::logs::LogRecor
    * @return return true when all data are exported, and false when timeout
    */
   bool ForceFlush(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
 
   /**
    * Marks the OStream Log Exporter as shut down.
    */
   bool Shutdown(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
 
 private:
   // The OStream to send the logs to

exporters/ostream/include/opentelemetry/exporters/ostream/span_exporter.h

@@ -44,10 +44,10 @@ class OStreamSpanExporter final : public opentelemetry::sdk::trace::SpanExporter
    * @return return true when all data are exported, and false when timeout
    */
   bool ForceFlush(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
 
   bool Shutdown(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
 
 private:
   std::ostream &sout_;

exporters/zipkin/include/opentelemetry/exporters/zipkin/zipkin_exporter.h

@@ -55,14 +55,14 @@ class ZipkinExporter final : public opentelemetry::sdk::trace::SpanExporter
    * @return return true when all data are exported, and false when timeout
    */
   bool ForceFlush(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
 
   /**
    * Shut down the exporter.
    * @param timeout an optional timeout, default to max.
    */
   bool Shutdown(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
 
 private:
   void InitializeLocalEndpoint();

sdk/include/opentelemetry/sdk/logs/exporter.h

@@ -62,7 +62,7 @@ class OPENTELEMETRY_EXPORT LogRecordExporter
    * @return true if the exporter shutdown succeeded, false otherwise
    */
   virtual bool Shutdown(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept = 0;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept = 0;
 };
 }  // namespace logs
 }  // namespace sdk

sdk/include/opentelemetry/sdk/logs/logger_context.h

@@ -70,7 +70,7 @@ class LoggerContext
   /**
    * Shutdown the log processor associated with this tracer provider.
    */
-  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept;
+  bool Shutdown(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept;
 
 private:
   //  order of declaration is important here - resource object should be destroyed after processor.

sdk/include/opentelemetry/sdk/logs/processor.h

@@ -46,7 +46,7 @@ class LogRecordProcessor
    * @return a result code indicating whether it succeeded, failed or timed out
    */
   virtual bool ForceFlush(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept = 0;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept = 0;
 
   /**
    * Shuts down the processor and does any cleanup required.
@@ -56,7 +56,7 @@ class LogRecordProcessor
    * @return true if the shutdown succeeded, false otherwise
    */
   virtual bool Shutdown(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept = 0;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept = 0;
 };
 }  // namespace logs
 }  // namespace sdk

sdk/include/opentelemetry/sdk/logs/simple_log_record_processor.h

@@ -39,10 +39,10 @@ class SimpleLogRecordProcessor : public LogRecordProcessor
   void OnEmit(std::unique_ptr<Recordable> &&record) noexcept override;
 
   bool ForceFlush(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
 
   bool Shutdown(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
 
   bool IsShutdown() const noexcept;
 

sdk/include/opentelemetry/sdk/metrics/aggregation/histogram_aggregation.h

@@ -93,8 +93,8 @@ void HistogramMerge(HistogramPointData &current,
   merge.record_min_max_ = current.record_min_max_ && delta.record_min_max_;
   if (merge.record_min_max_)
   {
-    merge.min_ = std::min(nostd::get<T>(current.min_), nostd::get<T>(delta.min_));
-    merge.max_ = std::max(nostd::get<T>(current.max_), nostd::get<T>(delta.max_));
+    merge.min_ = (std::min)(nostd::get<T>(current.min_), nostd::get<T>(delta.min_));
+    merge.max_ = (std::max)(nostd::get<T>(current.max_), nostd::get<T>(delta.max_));
   }
 }
 

sdk/include/opentelemetry/sdk/metrics/metric_reader.h

@@ -48,12 +48,12 @@ class MetricReader
   /**
    * Shutdown the metric reader.
    */
-  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept;
+  bool Shutdown(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept;
 
   /**
    * Force flush the metric read by the reader.
    */
-  bool ForceFlush(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept;
+  bool ForceFlush(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept;
 
   /**
    * Return the status of Metric reader.

sdk/include/opentelemetry/sdk/metrics/state/metric_collector.h

@@ -53,9 +53,9 @@ class MetricCollector : public MetricProducer, public CollectorHandle
    */
   bool Collect(nostd::function_ref<bool(ResourceMetrics &metric_data)> callback) noexcept override;
 
-  bool ForceFlush(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept;
+  bool ForceFlush(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept;
 
-  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept;
+  bool Shutdown(std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept;
 
 private:
   MeterContext *meter_context_;

sdk/include/opentelemetry/sdk/trace/exporter.h

@@ -61,7 +61,7 @@ class OPENTELEMETRY_EXPORT SpanExporter
    * @return return the status of the operation.
    */
   virtual bool Shutdown(
-      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept = 0;
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept = 0;
 };
 }  // namespace trace
 }  // namespace sdk

sdk/src/logs/batch_log_record_processor.cc

@@ -104,7 +104,7 @@ bool BatchLogRecordProcessor::ForceFlush(std::chrono::microseconds timeout) noex
       std::chrono::duration_cast<std::chrono::steady_clock::duration>(timeout);
   if (timeout_steady <= std::chrono::steady_clock::duration::zero())
   {
-    timeout_steady = std::chrono::steady_clock::duration::max();
+    timeout_steady = (std::chrono::steady_clock::duration::max)();
   }
 
   bool result = false;

sdk/src/metrics/aggregation/histogram_aggregation.cc

@@ -38,8 +38,8 @@ LongHistogramAggregation::LongHistogramAggregation(const AggregationConfig *aggr
   point_data_.sum_            = (int64_t)0;
   point_data_.count_          = 0;
   point_data_.record_min_max_ = record_min_max_;
-  point_data_.min_            = std::numeric_limits<int64_t>::max();
-  point_data_.max_            = std::numeric_limits<int64_t>::min();
+  point_data_.min_            = (std::numeric_limits<int64_t>::max)();
+  point_data_.max_            = (std::numeric_limits<int64_t>::min)();
 }
 
 LongHistogramAggregation::LongHistogramAggregation(HistogramPointData &&data)
@@ -58,8 +58,8 @@ void LongHistogramAggregation::Aggregate(int64_t value,
   point_data_.sum_ = nostd::get<int64_t>(point_data_.sum_) + value;
   if (record_min_max_)
   {
-    point_data_.min_ = std::min(nostd::get<int64_t>(point_data_.min_), value);
-    point_data_.max_ = std::max(nostd::get<int64_t>(point_data_.max_), value);
+    point_data_.min_ = (std::min)(nostd::get<int64_t>(point_data_.min_), value);
+    point_data_.max_ = (std::max)(nostd::get<int64_t>(point_data_.max_), value);
   }
   size_t index = BucketBinarySearch(value, point_data_.boundaries_);
   point_data_.counts_[index] += 1;
@@ -118,8 +118,8 @@ DoubleHistogramAggregation::DoubleHistogramAggregation(const AggregationConfig *
   point_data_.sum_            = 0.0;
   point_data_.count_          = 0;
   point_data_.record_min_max_ = record_min_max_;
-  point_data_.min_            = std::numeric_limits<double>::max();
-  point_data_.max_            = std::numeric_limits<double>::min();
+  point_data_.min_            = (std::numeric_limits<double>::max)();
+  point_data_.max_            = (std::numeric_limits<double>::min)();
 }
 
 DoubleHistogramAggregation::DoubleHistogramAggregation(HistogramPointData &&data)
@@ -138,8 +138,8 @@ void DoubleHistogramAggregation::Aggregate(double value,
   point_data_.sum_ = nostd::get<double>(point_data_.sum_) + value;
   if (record_min_max_)
   {
-    point_data_.min_ = std::min(nostd::get<double>(point_data_.min_), value);
-    point_data_.max_ = std::max(nostd::get<double>(point_data_.max_), value);
+    point_data_.min_ = (std::min)(nostd::get<double>(point_data_.min_), value);
+    point_data_.max_ = (std::max)(nostd::get<double>(point_data_.max_), value);
   }
   size_t index = BucketBinarySearch(value, point_data_.boundaries_);
   point_data_.counts_[index] += 1;

sdk/src/metrics/export/periodic_exporting_metric_reader.cc

@@ -133,7 +133,7 @@ bool PeriodicExportingMetricReader::OnForceFlush(std::chrono::microseconds timeo
       std::chrono::duration_cast<std::chrono::steady_clock::duration>(wait_timeout);
   if (timeout_steady <= std::chrono::steady_clock::duration::zero())
   {
-    timeout_steady = std::chrono::steady_clock::duration::max();
+    timeout_steady = (std::chrono::steady_clock::duration::max)();
   }
 
   bool result = false;

sdk/src/metrics/meter_context.cc

@@ -136,15 +136,15 @@ bool MeterContext::ForceFlush(std::chrono::microseconds timeout) noexcept
   // Simultaneous flush not allowed.
   const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(forceflush_lock_);
   // Convert to nanos to prevent overflow
-  auto timeout_ns = std::chrono::nanoseconds::max();
+  auto timeout_ns = (std::chrono::nanoseconds::max)();
   if (std::chrono::duration_cast<std::chrono::microseconds>(timeout_ns) > timeout)
   {
     timeout_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(timeout);
   }
 
   auto current_time = std::chrono::system_clock::now();
   std::chrono::system_clock::time_point expire_time;
-  auto overflow_checker = std::chrono::system_clock::time_point::max();
+  auto overflow_checker = (std::chrono::system_clock::time_point::max)();
 
   // check if the expected expire time doesn't overflow.
   if (overflow_checker - current_time > timeout_ns)

sdk/src/trace/batch_span_processor.cc

@@ -102,7 +102,7 @@ bool BatchSpanProcessor::ForceFlush(std::chrono::microseconds timeout) noexcept
       std::chrono::duration_cast<std::chrono::steady_clock::duration>(timeout);
   if (timeout_steady <= std::chrono::steady_clock::duration::zero())
   {
-    timeout_steady = std::chrono::steady_clock::duration::max();
+    timeout_steady = (std::chrono::steady_clock::duration::max)();
   }
 
   bool result = false;