grpc 1.62.3 → 1.63.0

data/third_party/abseil-cpp/absl/log/internal/log_format.cc

@@ -0,0 +1,205 @@
+//
+// Copyright 2022 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/log/internal/log_format.h"
+
+#include <string.h>
+
+#ifdef _MSC_VER
+#include <winsock2.h>  // For timeval
+#else
+#include <sys/time.h>
+#endif
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/base/log_severity.h"
+#include "absl/base/optimization.h"
+#include "absl/log/internal/append_truncated.h"
+#include "absl/log/internal/config.h"
+#include "absl/log/internal/globals.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/civil_time.h"
+#include "absl/time/time.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+namespace {
+
+// This templated function avoids compiler warnings about tautological
+// comparisons when log_internal::Tid is unsigned. It can be replaced with a
+// constexpr if once the minimum C++ version Abseil supports is C++17.
+template <typename T>
+inline std::enable_if_t<!std::is_signed<T>::value>
+PutLeadingWhitespace(T tid, char*& p) {
+  if (tid < 10) *p++ = ' ';
+  if (tid < 100) *p++ = ' ';
+  if (tid < 1000) *p++ = ' ';
+  if (tid < 10000) *p++ = ' ';
+  if (tid < 100000) *p++ = ' ';
+  if (tid < 1000000) *p++ = ' ';
+}
+
+template <typename T>
+inline std::enable_if_t<std::is_signed<T>::value>
+PutLeadingWhitespace(T tid, char*& p) {
+  if (tid >= 0 && tid < 10) *p++ = ' ';
+  if (tid > -10 && tid < 100) *p++ = ' ';
+  if (tid > -100 && tid < 1000) *p++ = ' ';
+  if (tid > -1000 && tid < 10000) *p++ = ' ';
+  if (tid > -10000 && tid < 100000) *p++ = ' ';
+  if (tid > -100000 && tid < 1000000) *p++ = ' ';
+}
+
+// The fields before the filename are all fixed-width except for the thread ID,
+// which is of bounded width.
+size_t FormatBoundedFields(absl::LogSeverity severity, absl::Time timestamp,
+                           log_internal::Tid tid, absl::Span<char>& buf) {
+  constexpr size_t kBoundedFieldsMaxLen =
+      sizeof("SMMDD HH:MM:SS.NNNNNN  ") +
+      (1 + std::numeric_limits<log_internal::Tid>::digits10 + 1) - sizeof("");
+  if (ABSL_PREDICT_FALSE(buf.size() < kBoundedFieldsMaxLen)) {
+    // We don't bother trying to truncate these fields if the buffer is too
+    // short (or almost too short) because it would require doing a lot more
+    // length checking (slow) and it should never happen.  A 15kB buffer should
+    // be enough for anyone.  Instead we mark `buf` full without writing
+    // anything.
+    buf.remove_suffix(buf.size());
+    return 0;
+  }
+
+  // We can't call absl::LocalTime(), localtime_r(), or anything else here that
+  // isn't async-signal-safe. We can only use the time zone if it has already
+  // been loaded.
+  const absl::TimeZone* tz = absl::log_internal::TimeZone();
+  if (ABSL_PREDICT_FALSE(tz == nullptr)) {
+    // If a time zone hasn't been set yet because we are logging before the
+    // logging library has been initialized, we fallback to a simpler, slower
+    // method. Just report the raw Unix time in seconds. We cram this into the
+    // normal time format for the benefit of parsers.
+    auto tv = absl::ToTimeval(timestamp);
+    int snprintf_result = absl::SNPrintF(
+        buf.data(), buf.size(), "%c0000 00:00:%02d.%06d %7d ",
+        absl::LogSeverityName(severity)[0], static_cast<int>(tv.tv_sec),
+        static_cast<int>(tv.tv_usec), static_cast<int>(tid));
+    if (snprintf_result >= 0) {
+      buf.remove_prefix(static_cast<size_t>(snprintf_result));
+      return static_cast<size_t>(snprintf_result);
+    }
+    return 0;
+  }
+
+  char* p = buf.data();
+  *p++ = absl::LogSeverityName(severity)[0];
+  const absl::TimeZone::CivilInfo ci = tz->At(timestamp);
+  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.month()), p);
+  p += 2;
+  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.day()), p);
+  p += 2;
+  *p++ = ' ';
+  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.hour()), p);
+  p += 2;
+  *p++ = ':';
+  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.minute()),
+                                       p);
+  p += 2;
+  *p++ = ':';
+  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.second()),
+                                       p);
+  p += 2;
+  *p++ = '.';
+  const int64_t usecs = absl::ToInt64Microseconds(ci.subsecond);
+  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(usecs / 10000), p);
+  p += 2;
+  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(usecs / 100 % 100),
+                                       p);
+  p += 2;
+  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(usecs % 100), p);
+  p += 2;
+  *p++ = ' ';
+  PutLeadingWhitespace(tid, p);
+  p = absl::numbers_internal::FastIntToBuffer(tid, p);
+  *p++ = ' ';
+  const size_t bytes_formatted = static_cast<size_t>(p - buf.data());
+  buf.remove_prefix(bytes_formatted);
+  return bytes_formatted;
+}
+
+size_t FormatLineNumber(int line, absl::Span<char>& buf) {
+  constexpr size_t kLineFieldMaxLen =
+      sizeof(":] ") + (1 + std::numeric_limits<int>::digits10 + 1) - sizeof("");
+  if (ABSL_PREDICT_FALSE(buf.size() < kLineFieldMaxLen)) {
+    // As above, we don't bother trying to truncate this if the buffer is too
+    // short and it should never happen.
+    buf.remove_suffix(buf.size());
+    return 0;
+  }
+  char* p = buf.data();
+  *p++ = ':';
+  p = absl::numbers_internal::FastIntToBuffer(line, p);
+  *p++ = ']';
+  *p++ = ' ';
+  const size_t bytes_formatted = static_cast<size_t>(p - buf.data());
+  buf.remove_prefix(bytes_formatted);
+  return bytes_formatted;
+}
+
+}  // namespace
+
+std::string FormatLogMessage(absl::LogSeverity severity,
+                             absl::CivilSecond civil_second,
+                             absl::Duration subsecond, log_internal::Tid tid,
+                             absl::string_view basename, int line,
+                             PrefixFormat format, absl::string_view message) {
+  return absl::StrFormat(
+      "%c%02d%02d %02d:%02d:%02d.%06d %7d %s:%d] %s%s",
+      absl::LogSeverityName(severity)[0], civil_second.month(),
+      civil_second.day(), civil_second.hour(), civil_second.minute(),
+      civil_second.second(), absl::ToInt64Microseconds(subsecond), tid,
+      basename, line, format == PrefixFormat::kRaw ? "RAW: " : "", message);
+}
+
+// This method is fairly hot, and the library always passes a huge `buf`, so we
+// save some bounds-checking cycles by not trying to do precise truncation.
+// Truncating at a field boundary is probably a better UX anyway.
+//
+// The prefix is written in three parts, each of which does a single
+// bounds-check and truncation:
+// 1. severity, timestamp, and thread ID
+// 2. filename
+// 3. line number and bracket
+size_t FormatLogPrefix(absl::LogSeverity severity, absl::Time timestamp,
+                       log_internal::Tid tid, absl::string_view basename,
+                       int line, PrefixFormat format, absl::Span<char>& buf) {
+  auto prefix_size = FormatBoundedFields(severity, timestamp, tid, buf);
+  prefix_size += log_internal::AppendTruncated(basename, buf);
+  prefix_size += FormatLineNumber(line, buf);
+  if (format == PrefixFormat::kRaw)
+    prefix_size += log_internal::AppendTruncated("RAW: ", buf);
+  return prefix_size;
+}
+
+}  // namespace log_internal
+ABSL_NAMESPACE_END
+}  // namespace absl

data/third_party/abseil-cpp/absl/log/internal/log_format.h

@@ -0,0 +1,78 @@
+// Copyright 2022 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: log/internal/log_format.h
+// -----------------------------------------------------------------------------
+//
+// This file declares routines implementing formatting of log message and log
+// prefix.
+
+#ifndef ABSL_LOG_INTERNAL_LOG_FORMAT_H_
+#define ABSL_LOG_INTERNAL_LOG_FORMAT_H_
+
+#include <stddef.h>
+
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/base/log_severity.h"
+#include "absl/log/internal/config.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/civil_time.h"
+#include "absl/time/time.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+
+enum class PrefixFormat {
+  kNotRaw,
+  kRaw,
+};
+
+// Formats log message based on provided data.
+std::string FormatLogMessage(absl::LogSeverity severity,
+                             absl::CivilSecond civil_second,
+                             absl::Duration subsecond, log_internal::Tid tid,
+                             absl::string_view basename, int line,
+                             PrefixFormat format, absl::string_view message);
+
+// Formats various entry metadata into a text string meant for use as a
+// prefix on a log message string.  Writes into `buf`, advances `buf` to point
+// at the remainder of the buffer (i.e. past any written bytes), and returns the
+// number of bytes written.
+//
+// In addition to calling `buf->remove_prefix()` (or the equivalent), this
+// function may also do `buf->remove_suffix(buf->size())` in cases where no more
+// bytes (i.e. no message data) should be written into the buffer.  For example,
+// if the prefix ought to be:
+//   I0926 09:00:00.000000 1234567 foo.cc:123]
+// `buf` is too small, the function might fill the whole buffer:
+//   I0926 09:00:00.000000 1234
+// (note the apparrently incorrect thread ID), or it might write less:
+//   I0926 09:00:00.000000
+// In this case, it might also empty `buf` prior to returning to prevent
+// message data from being written into the space where a reader would expect to
+// see a thread ID.
+size_t FormatLogPrefix(absl::LogSeverity severity, absl::Time timestamp,
+                       log_internal::Tid tid, absl::string_view basename,
+                       int line, PrefixFormat format, absl::Span<char>& buf);
+
+}  // namespace log_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_LOG_INTERNAL_LOG_FORMAT_H_

data/third_party/abseil-cpp/absl/log/internal/log_impl.h

@@ -0,0 +1,282 @@
+// Copyright 2022 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_LOG_INTERNAL_LOG_IMPL_H_
+#define ABSL_LOG_INTERNAL_LOG_IMPL_H_
+
+#include "absl/log/absl_vlog_is_on.h"
+#include "absl/log/internal/conditions.h"
+#include "absl/log/internal/log_message.h"
+#include "absl/log/internal/strip.h"
+
+// ABSL_LOG()
+#define ABSL_LOG_INTERNAL_LOG_IMPL(severity)             \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+// ABSL_PLOG()
+#define ABSL_LOG_INTERNAL_PLOG_IMPL(severity)              \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true)   \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream() \
+          .WithPerror()
+
+// ABSL_DLOG()
+#ifndef NDEBUG
+#define ABSL_LOG_INTERNAL_DLOG_IMPL(severity)            \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+#else
+#define ABSL_LOG_INTERNAL_DLOG_IMPL(severity)             \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, false) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+#endif
+
+// The `switch` ensures that this expansion is the begnning of a statement (as
+// opposed to an expression). The use of both `case 0` and `default` is to
+// suppress a compiler warning.
+#define ABSL_LOG_INTERNAL_VLOG_IMPL(verbose_level)                         \
+  switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
+  case 0:                                                                  \
+  default:                                                                 \
+    ABSL_LOG_INTERNAL_LOG_IF_IMPL(                                         \
+        _INFO, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))       \
+        .WithVerbosity(absl_logging_internal_verbose_level)
+
+#ifndef NDEBUG
+#define ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level)                        \
+  switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
+  case 0:                                                                  \
+  default:                                                                 \
+    ABSL_LOG_INTERNAL_LOG_IF_IMPL(                                         \
+        _INFO, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))       \
+        .WithVerbosity(absl_logging_internal_verbose_level)
+#else
+#define ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level)                           \
+  switch (const int absl_logging_internal_verbose_level = (verbose_level))    \
+  case 0:                                                                     \
+  default:                                                                    \
+    ABSL_LOG_INTERNAL_LOG_IF_IMPL(                                            \
+        _INFO, false && ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level)) \
+        .WithVerbosity(absl_logging_internal_verbose_level)
+#endif
+
+#define ABSL_LOG_INTERNAL_LOG_IF_IMPL(severity, condition)    \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, condition) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+#define ABSL_LOG_INTERNAL_PLOG_IF_IMPL(severity, condition)   \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, condition) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()    \
+          .WithPerror()
+
+#ifndef NDEBUG
+#define ABSL_LOG_INTERNAL_DLOG_IF_IMPL(severity, condition)   \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, condition) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+#else
+#define ABSL_LOG_INTERNAL_DLOG_IF_IMPL(severity, condition)              \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, false && (condition)) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+#endif
+
+// ABSL_LOG_EVERY_N
+#define ABSL_LOG_INTERNAL_LOG_EVERY_N_IMPL(severity, n)            \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+// ABSL_LOG_FIRST_N
+#define ABSL_LOG_INTERNAL_LOG_FIRST_N_IMPL(severity, n)            \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(FirstN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+// ABSL_LOG_EVERY_POW_2
+#define ABSL_LOG_INTERNAL_LOG_EVERY_POW_2_IMPL(severity)           \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryPow2) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+// ABSL_LOG_EVERY_N_SEC
+#define ABSL_LOG_INTERNAL_LOG_EVERY_N_SEC_IMPL(severity, n_seconds)           \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryNSec, n_seconds) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_PLOG_EVERY_N_IMPL(severity, n)           \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()         \
+          .WithPerror()
+
+#define ABSL_LOG_INTERNAL_PLOG_FIRST_N_IMPL(severity, n)           \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(FirstN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()         \
+          .WithPerror()
+
+#define ABSL_LOG_INTERNAL_PLOG_EVERY_POW_2_IMPL(severity)          \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryPow2) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()         \
+          .WithPerror()
+
+#define ABSL_LOG_INTERNAL_PLOG_EVERY_N_SEC_IMPL(severity, n_seconds)          \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryNSec, n_seconds) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()                    \
+          .WithPerror()
+
+#ifndef NDEBUG
+#define ABSL_LOG_INTERNAL_DLOG_EVERY_N_IMPL(severity, n) \
+  ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, true)       \
+  (EveryN, n) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_FIRST_N_IMPL(severity, n) \
+  ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, true)       \
+  (FirstN, n) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_EVERY_POW_2_IMPL(severity) \
+  ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, true)        \
+  (EveryPow2) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_EVERY_N_SEC_IMPL(severity, n_seconds) \
+  ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, true)                   \
+  (EveryNSec, n_seconds) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#else  // def NDEBUG
+#define ABSL_LOG_INTERNAL_DLOG_EVERY_N_IMPL(severity, n) \
+  ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, false)      \
+  (EveryN, n) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_FIRST_N_IMPL(severity, n) \
+  ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, false)      \
+  (FirstN, n) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_EVERY_POW_2_IMPL(severity) \
+  ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, false)       \
+  (EveryPow2) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_EVERY_N_SEC_IMPL(severity, n_seconds) \
+  ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, false)                  \
+  (EveryNSec, n_seconds) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+#endif  // def NDEBUG
+
+#define ABSL_LOG_INTERNAL_VLOG_EVERY_N_IMPL(verbose_level, n)                \
+  switch (const int absl_logging_internal_verbose_level = (verbose_level))   \
+  case 0:                                                                    \
+  default:                                                                   \
+    ABSL_LOG_INTERNAL_CONDITION_INFO(                                        \
+        STATEFUL, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))      \
+  (EveryN, n) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
+      absl_logging_internal_verbose_level)
+
+#define ABSL_LOG_INTERNAL_VLOG_FIRST_N_IMPL(verbose_level, n)                \
+  switch (const int absl_logging_internal_verbose_level = (verbose_level))   \
+  case 0:                                                                    \
+  default:                                                                   \
+    ABSL_LOG_INTERNAL_CONDITION_INFO(                                        \
+        STATEFUL, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))      \
+  (FirstN, n) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
+      absl_logging_internal_verbose_level)
+
+#define ABSL_LOG_INTERNAL_VLOG_EVERY_POW_2_IMPL(verbose_level)               \
+  switch (const int absl_logging_internal_verbose_level = (verbose_level))   \
+  case 0:                                                                    \
+  default:                                                                   \
+    ABSL_LOG_INTERNAL_CONDITION_INFO(                                        \
+        STATEFUL, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))      \
+  (EveryPow2) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
+      absl_logging_internal_verbose_level)
+
+#define ABSL_LOG_INTERNAL_VLOG_EVERY_N_SEC_IMPL(verbose_level, n_seconds)  \
+  switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
+  case 0:                                                                  \
+  default:                                                                 \
+    ABSL_LOG_INTERNAL_CONDITION_INFO(                                      \
+        STATEFUL, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))    \
+  (EveryNSec, n_seconds) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream()   \
+      .WithVerbosity(absl_logging_internal_verbose_level)
+
+#define ABSL_LOG_INTERNAL_LOG_IF_EVERY_N_IMPL(severity, condition, n)   \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_LOG_IF_FIRST_N_IMPL(severity, condition, n)   \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(FirstN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_LOG_IF_EVERY_POW_2_IMPL(severity, condition)  \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryPow2) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_LOG_IF_EVERY_N_SEC_IMPL(severity, condition,  \
+                                                  n_seconds)            \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryNSec, \
+                                                             n_seconds) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_PLOG_IF_EVERY_N_IMPL(severity, condition, n)  \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()              \
+          .WithPerror()
+
+#define ABSL_LOG_INTERNAL_PLOG_IF_FIRST_N_IMPL(severity, condition, n)  \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(FirstN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()              \
+          .WithPerror()
+
+#define ABSL_LOG_INTERNAL_PLOG_IF_EVERY_POW_2_IMPL(severity, condition) \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryPow2) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()              \
+          .WithPerror()
+
+#define ABSL_LOG_INTERNAL_PLOG_IF_EVERY_N_SEC_IMPL(severity, condition, \
+                                                   n_seconds)           \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryNSec, \
+                                                             n_seconds) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()              \
+          .WithPerror()
+
+#ifndef NDEBUG
+#define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_N_IMPL(severity, condition, n)  \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_IF_FIRST_N_IMPL(severity, condition, n)  \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(FirstN, n) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_POW_2_IMPL(severity, condition) \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryPow2) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_N_SEC_IMPL(severity, condition, \
+                                                   n_seconds)           \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryNSec, \
+                                                             n_seconds) \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#else  // def NDEBUG
+#define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_N_IMPL(severity, condition, n)   \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, false && (condition))( \
+      EveryN, n) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_IF_FIRST_N_IMPL(severity, condition, n)   \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, false && (condition))( \
+      FirstN, n) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_POW_2_IMPL(severity, condition)  \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, false && (condition))( \
+      EveryPow2) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+
+#define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_N_SEC_IMPL(severity, condition,  \
+                                                   n_seconds)            \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, false && (condition))( \
+      EveryNSec, n_seconds)                                              \
+      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+#endif  // def NDEBUG
+
+#endif  // ABSL_LOG_INTERNAL_LOG_IMPL_H_