Faster filtered log skipping.

Author: kevincox

sog/base.cc

@@ -34,12 +34,12 @@ void sog::init(sog::Sink *newsink) {
 		sink = new sog::PrettySink(&std::clog);
 }
 
-std::unique_ptr<sog::SinkData> sog::_prepare(const Source *s) {
+sog::Prepared sog::_prepare(const Source *s) {
 	return sink->prepare(s);
 }
 
 void sog::_submit(SinkData *d, Message m) {
 	sink->log(d, m);
 	if (m.source->level == level::FATAL)
-		abort();
+		std::terminate();
 }

sog/base.h

@@ -53,7 +53,7 @@ namespace sog {
 	struct Source;
 	struct Message;
 
-	using Level = uint8_t;
+	using Level = uint16_t;
 	namespace level {
 		constexpr Level FATAL = 0;
 		constexpr Level ERROR = 1;
@@ -73,6 +73,19 @@ namespace sog {
 		virtual ~SinkData();
 	};
 
+	struct Prepared final {
+		// Data to be passed to the sink.
+		std::unique_ptr<SinkData> sink_data;
+		
+		/** Should messages from this sink be logged.
+		 *
+		 * If false log() will never be called for this source.
+		 *
+		 * This can be used to cheaply drop messages that will never be logged.
+		 */
+		bool log = true;
+	};
+	
 	/** A log source.
 	 * 
 	 * A source is a collection of metadata about a "type" of log message. This
@@ -142,7 +155,7 @@ namespace sog {
 			source(source), values(&*vals.begin()) {}
 	};
 
-	std::unique_ptr<SinkData> _prepare(const Source *s);
+	Prepared _prepare(const Source *s);
 	void _submit(SinkData *d, Message m);
 }
 

sog/dynamic.cc

@@ -5,6 +5,7 @@ void sog::DynamicLog::submit() {
 	message.values = values.data();
 	source.value_count = values.size();
 
-	std::unique_ptr<sog::SinkData> sd { sog::_prepare(&source) };
-	sog::_submit(sd.get(), std::move(message));
+	auto prepare = sog::_prepare(&source);
+	if (prepare.log)
+		sog::_submit(prepare.sink_data.get(), std::move(message));
 }

sog/journald.cc

@@ -81,8 +81,8 @@ sog::JournaldSink::JournaldSink() {
 	}
 }
 
-std::unique_ptr<sog::SinkData> sog::JournaldSink::prepare(const sog::Source *source) {
-	return std::make_unique<Data>(source);
+sog::Prepared sog::JournaldSink::prepare(const sog::Source *source) {
+	return { std::make_unique<Data>(source) };
 }
 
 sog::Logged sog::JournaldSink::log(sog::SinkData *sd, sog::Message msg) {

sog/journald.h

@@ -11,7 +11,7 @@ namespace sog {
 		~JournaldSink();
 		JournaldSink();
 
-		std::unique_ptr<SinkData> prepare(const Source *source) override;
+		Prepared prepare(const Source *source) override;
 		Logged log(SinkData *sd, Message msg) override;
 	};
 }

sog/json.cc

@@ -83,8 +83,8 @@ struct Data: public sog::SinkData {
 
 }
 
-std::unique_ptr<sog::SinkData> sog::JsonSink::prepare(const sog::Source *source) {
-	return std::make_unique<Data>(source);
+sog::Prepared sog::JsonSink::prepare(const sog::Source *source) {
+	return { std::make_unique<Data>(source) };
 }
 
 sog::Logged sog::JsonSink::log(sog::SinkData *sd, sog::Message msg) {

sog/json.h

@@ -12,7 +12,7 @@ namespace sog {
 		std::ostream *out;
 
 		JsonSink(std::ostream *out): out{out} {}
-		std::unique_ptr<SinkData> prepare(const Source *source) override;
+		Prepared prepare(const Source *source) override;
 		Logged log(SinkData *sd, Message msg) override;
 	};
 }

sog/macro.h

@@ -118,9 +118,10 @@ namespace sog {
 		}; \
 		static_assert(::sog::_is_valid(&_sog_source), \
 			"Invalid template string (check formatting and argument names.)"); \
-		static std::unique_ptr<::sog::SinkData> _sog_sink_data = \
-			::sog::_prepare(&_sog_source); \
-		::sog::_submit(_sog_sink_data.get(), ::sog::Message(&_sog_source, { vals })); \
+		static sog::Prepared _sog_prepared = ::sog::_prepare(&_sog_source); \
+		if (!_sog_prepared.log) \
+			break; \
+		::sog::_submit(_sog_prepared.sink_data.get(), ::sog::Message(&_sog_source, { vals })); \
 	} while(false)
 
 #define _sog_KEYS(r, _, i, e, ...) \

sog/pretty.cc

@@ -44,17 +44,15 @@ struct Data: public sog::SinkData {
 
 }
 
-std::unique_ptr<sog::SinkData> sog::PrettySink::prepare(const sog::Source *source) {
+sog::Prepared sog::PrettySink::prepare(const sog::Source *source) {
 	if (source->msg_template.empty())
-		return nullptr;
+		return { nullptr, false };
 
-	return std::make_unique<Data>(source);
+	return { std::make_unique<Data>(source) };
 }
 
 sog::Logged sog::PrettySink::log(sog::SinkData *sd, sog::Message msg) {
-	if (!sd)
-		return {};
-	
+	assert(sd);
 	Data *data = dynamic_cast<Data*>(sd);
 
 	timeval time;

sog/pretty.h

@@ -12,7 +12,7 @@ namespace sog {
 		std::ostream *out;
 
 		PrettySink(std::ostream *out): out{out} {}
-		std::unique_ptr<SinkData> prepare(const Source *source) override;
+		Prepared prepare(const Source *source) override;
 		Logged log(SinkData *sd, Message msg) override;
 	};
 }

sog/sink.cc

@@ -34,6 +34,6 @@ char sog::level_char(sog::Level l) {
 	return LEVEL_CHARS[i];
 }
 
-std::unique_ptr<sog::SinkData> sog::Sink::prepare(const Source *source) {
-	return nullptr;
+sog::Prepared sog::Sink::prepare(const Source *source) {
+	return { nullptr };
 }

sog/sink.h

@@ -13,7 +13,7 @@ namespace sog {
 	};
 
 	/** Sink interface.
-	 * 
+	 *
 	 * This is the interface that should be written to for consuming messages
 	 * logged with sog. It is not expected that users will call this interface
 	 * themselves.
@@ -22,47 +22,47 @@ namespace sog {
 		virtual ~Sink() {}
 
 		/** Prepare data for a source.
-		 * 
+		 *
 		 * This method will be called once for every source. The value returned
 		 * will be deleted if the source is ever destructed. Note that in normal
 		 * use of sog sources are never destructed but there is an API provided
 		 * for "dynamic" logging in which the destruction of sources is common.
-		 * 
+		 *
 		 * @warning This function must be reentrant. It will only be called once
 		 *	for any given source but it may be called for multiple sources
 		 *	concurrently.
-		 * 
+		 *
 		 * @param source The source to prepare for.
 		 * @return Arbitrary data.
 		 */
-		virtual std::unique_ptr<SinkData> prepare(const Source *source);
+		virtual Prepared prepare(const Source *source);
 
 		/** Log a message.
-		 * 
+		 *
 		 * This message provides the sink data from a previous call to prepare
 		 * and a sog::Message. The msg.source attribute will be the same source
 		 * (both in location and content) as the source passed to the prepare()
 		 * call that produced sink_data.
-		 * 
+		 *
 		 * @warning This function must be reentrant. It will be called
 		 *	concurrently for the same and different sinks.
-		 * 
+		 *
 		 * @param sink_data Data from a previous call to prepare()
 		 * @param msg The message to log.
 		 */
 		virtual Logged log(SinkData *sink_data, Message msg) = 0;
 	};
 
 	/** Get the name of a log level.
-	 * 
+	 *
 	 * Returns a string_view to a static string describing the log level. Note
 	 * that some log levels return the same string (in particular high log
 	 * levels return TRACE irrespective of their specific value).
 	 */
 	std::experimental::string_view level_name(sog::Level level);
 
 	/** Get a character representing a log level.
-	 * 
+	 *
 	 * Note that the returned charcter isn't necessarily unique for a give log
 	 * level (see sog::level_name()).
 	 */