test.cpp

template <typename T> constexpr T bitfield (T bit) { return 1 << bit; }

namespace Telemetry {
  enum TelemetryType {
    Guage   = bitfield(0),
    Counter = bitfield(1),
    Debug   = bitfield(2),
    Info    = bitfield(3),
    Warn    = bitfield(4),
    Error   = bitfield(5)
  };
  
  namespace internal {
    extern unsigned int enabled_telemetry_flags;
    extern std::map<std::string, unsigned> counters;

    template <TelemetryType T, typename... Args>
    struct Recorder {
      static inline void record () {
        std::cout << "Generic recorder called for type " << T << " with " << sizeof...(Args) << " arguments.\n";
      }
    };
    
    template <typename... Args>
    struct Recorder<Counter, Args...> {
      static inline void record (const std::string& name, unsigned increment) {
        unsigned value = counters[name] += increment;
        std::cout << "Counter " << name << " incremented by " << increment << ". New value: " << value << "\n";
      }
    };
    
    template <typename T, typename... Args>
    struct Recorder<Info, T, Args...> {
      static inline void record (T first, Args... rest) {
        std::cout << first;
        Recorder<Info, Args...>::record(rest...);
      }
    };
    template <typename T>
    struct Recorder<Info, T> {
      static inline void record (T first) {
        std::cout << first;
      }
    };
  }
  
  template <TelemetryType T, typename... Args>
  inline void record (Args... args) {
    if (internal::enabled_telemetry_flags & T) {
      internal::Recorder<T, Args...>::record(args...);
    }
  }
}

int main ()
{
  Telemetry::record<Telemetry::Counter>("foo", 2);
  // outputs: Counter foo incremented by 2. New value: 2
  Telemetry::record<Telemetry::Info>("Something with value ", 4, " happened.");
  // untested, but should output: Something with value 4 happened.
  return 0;
}