I’m writing a excessive efficiency software which is able to get hit onerous through the community and must implement logging (to a textual content file) as effectively.
Is it a good suggestion to have a buffer with a separate goroutine slowly draining the buffer to a file, or is log.Println (to a file) already optimised sufficient to keep away from this being crucial?
Wanting on the implementation of
log.Println, I see it simply delegates to
fmt.Sprintln and finally calls
(*log.Logger).Output which simply calls
Write on the logger’s configured output right here. There doesn’t appear to be any form of optimization. If the underlying
io.Author implementation doesn’t buffer its writes, this could possibly be a bottleneck should you’re doing a lot of logging. Be aware additionally that
*log.Logger has a
sync.Mutex to verify writes are atomic, so just one log message might be written at a time.
You might strive utilizing
(*log.Logger).SetOutput to set the logging output to a
*bufio.Author which ought to let most logging operations full extra rapidly, nonetheless it’s important to make sure that to name
(*bufio.Author).Flush so that each one the log messages really get flushed to the underlying author. Perhaps it has to go in a
defer assertion in case of a panic.
How do you propose to do that? You might presumably use
(*log.Logger).SetOutput to set the output to, e.g. a
*bytes.Buffer, however then how would you talk to a different goroutine to flush the buffer? Perhaps you can use a wrapper round
(*bytes.Buffer).Write that checks the buffer capability and makes use of, e.g., a channel to sign to the author goroutine to flush the buffer, however then you definitely additionally must await the flush to finish. I don’t suppose that will get you a lot over the
*bufio.Author different apart from permitting the final goroutine that crammed the buffer to proceed whereas the author goroutine really flushes the buffer. Nonetheless, the subsequent name from any goroutine to any of the logging capabilities will block till that author goroutine completes the flush.
You probably have loads of requests with loads of log occasions per request, maybe you can use separate
*log.Logger cases with separate (maybe buffered) outputs. It could end in separate information which can or is probably not a deal-breaker, however the efficiency of writing out to the information wouldn’t be bottlenecked by one
*log.Logger‘s mutex or by the underlying author.
This subject was mechanically closed 90 days after the final reply. New replies are not allowed.