GODRIVER-2904 Add environment log.

[qingyang-hu]

GODRIVER-2904

Summary

Log informational message client-side based on detected environment (DocumentDB or CosmosDB)

Background & Motivation

Log informational messages by examining host names added to a topology.
SRV connection strings are not tested, since initial lookup responses cannot be easily mocked.

[blink1073]

LGTM!

[jyemin]

DoumentDB -> DocumentDB

[qingyang-hu]

Thank you!

[prestonvasquez]

Suggest making cosmosDBLog and documentDBLog constants. See comments on restructuring.

[prestonvasquez]

I don't think we should have a struct for logging. IIUC the only reason we do this is to maintain state so as not to repeated logs for the same host. However, it might be best to maintain this state in the code that is calling the logger, to minimize any leaking:

			hostSet := map[string]bool{}
			for _, host := range parsedHosts {
				if h, _, err := net.SplitHostPort(host); err == nil {
					host = h
				}

				if !hostSet[host] {
					logTopoloygThirdPartyUsage(t, host)
				}

				hostSet[host] = true
			}

[prestonvasquez]

Whether we decided to use a struct or not, we should re-organize the code to match the existing "logTopology*" pattern:

func logTopologyThirdPartyUsage(topo *Topology, host string) {
	thirdPartyMessages := map[string]string{
		".cosmos.azure.com":            cosmosDBLog,
		".docdb.amazonaws.com":         documentDBLog,
		".docdb-elastic.amazonaws.com": documentDBLog,
	}

	for tphost, msg := range thirdPartyMessages {
		if !strings.HasSuffix(host, tphost) {
			continue
		}

		// Serialize the topology message to be consistent with other topology
		// messages.
		topo.cfg.logger.Print(logger.LevelInfo,
			logger.ComponentTopology,
			msg,
			logger.SerializeTopology(logger.Topology{ID: topo.id, Message: msg})...)
	}
}

[prestonvasquez]

Before we log, we first need to check if it is appropriate to log. We should update mustLogTopologyMessage to the following:

func mustLogTopologyMessage(topo *Topology, level logger.Level) bool {
	return topo.cfg.logger != nil && topo.cfg.logger.LevelComponentEnabled(
		level, logger.ComponentTopology)
}

and then wrap this block:

		if mustLogTopologyMessage(t, logger.LevelInfo) {
			hostSet := map[string]bool{}
			for _, host := range parsedHosts {
				if h, _, err := net.SplitHostPort(host); err == nil {
					host = h
				}

				if !hostSet[host] {
					logTopologyThirdPartyUsage(t, host)
				}

				hostSet[host] = true
			}
		}

[qingyang-hu]

The check is done on the SRV's CNAME prior to SRV lookup as per the comment.

[prestonvasquez]

Optional: the only purpose of this block is to log third party connection information. It could be cleaner to create a separate function called logTopologyThirdPartyUsage to hold all of this logic:

if mustLogTopologyMessage(t, logger.LevelInfo) {
    logTopologyThirdPartyUsage(...)
}

[prestonvasquez]

Optional: this else is not necessary, the logic can be written like this:

				if !strings.HasSuffix(host, suffix) {
					continue
				}
				
				if logged, ok := hostSet[env]; ok && logged {
					break
				} 
				
				hostSet[env] = true
				logTopologyMessage(t, logger.LevelInfo, thirdPartyMessages[env])

[prestonvasquez]

Optional: If we create a separate function (logTopologyThirdPartyUsage), then there is no need to create package-level variables, we can nest these declarations within the logging function to give them context.

[prestonvasquez]

We should directly reference the cosmosDBMsg in the test, and not use a non-test constant. There are a few reasons for this:

1. Test code won't change when production code is refactored. That is, if we use a constant here then refactoring the constant in the production code would break this test.
2. These tests might pass if the code is wrong. Any changes to the constants will be considered valid, for instance if we accidentally append a character to the constant.

This applies to the other test cases as well.

[prestonvasquez]

Should we use an assertion here? require will stop testing if it fails. This applies to the other subtests as well.

[prestonvasquez]

Can test can be parallelized? From my testing it appears it can be.

[prestonvasquez]

Optional: if these are re-defined for each subtest, then we can parallelize the subtests.