Method writeEvent

flow/Trace.cpp:379–423

	}

	void writeEvent(TraceEventFields fields, std::string trackLatestKey, bool trackError) {
		MutexHolder hold(mutex);

		annotateEvent(fields);

		if (!trackLatestKey.empty()) {
			fields.addField("TrackLatestType", "Original");
		}

		if (!isOpen() &&
		    (preopenOverflowCount > 0 || bufferLength + fields.sizeBytes() > TRACE_LOG_MAX_PREOPEN_BUFFER)) {
			++preopenOverflowCount;
			return;
		}

		// FIXME: What if we are using way too much memory for buffer?
		ASSERT(!isOpen() || fields.isAnnotated());
		eventBuffer.push_back(fields);
		bufferLength += fields.sizeBytes();

		if (g_network && g_network->isSimulated()) {
			// Throw an error if we have queued up a large number of events in simulation. This makes it easier to
			// diagnose cases where we get stuck in a loop logging trace events that eventually runs out of memory.
			// Without this we would never see any trace events from that loop, and it would be more difficult to
			// identify where the process is actually stuck.
			if (bufferLength > 1e8) {
				fprintf(stderr, "Trace log buffer overflow\n");
				fprintf(stderr, "Last event: %s\n", fields.toString().c_str());
				// Setting this to 0 avoids a recurse from the assertion trace event and also prevents a situation where
				// we roll the trace log only to log the single assertion event when using --crash.
				bufferLength = 0;
				ASSERT(false);
			}
			if (++tracedLines > FLOW_KNOBS->MAX_TRACE_LINES && failedLineOverflow == 0) {
				failedLineOverflow = 1; // we only want to do this once
			}
		}

		if (trackError) {
			latestEventCache.setLatestError(fields);
		}
		if (!trackLatestKey.empty()) {
			latestEventCache.set(trackLatestKey, fields);
		}
	}

	void log(int severity, const char* name, UID id, uint64_t event_ts) {
		if (!logTraceEventMetrics)