Add --max-comments-per-command configuration

Allow Atlantis administrators to cap the number of VCS comments that
will be created for a single command. (The default value is 0, which
means unlimited comments.)

If you're trying something like `TF_LOG=debug`, Atlantis can produce so
many comments that it becomes challenging to read your PR, or worse
still, your VCS might rate-limit Atlantis, effectively breaking your
ability to use it for an extended period of time. While this PR does not
change the default behavior, it's probably a good idea to set this flag
to something like 10.

Fixes #416.

Author: glasser

cmd/server.go

@@ -106,6 +106,7 @@ const (
 	LockingDBType                    = "locking-db-type"
 	LogLevelFlag                     = "log-level"
 	MarkdownTemplateOverridesDirFlag = "markdown-template-overrides-dir"
+	MaxCommentsPerCommand            = "max-comments-per-command"
 	ParallelPoolSize                 = "parallel-pool-size"
 	StatsNamespace                   = "stats-namespace"
 	AllowDraftPRs                    = "allow-draft-prs"
@@ -591,6 +592,10 @@ var intFlags = map[string]intFlag{
 			" If merge base is further behind than this number of commits from any of branches heads, full fetch will be performed.",
 		defaultValue: DefaultCheckoutDepth,
 	},
+	MaxCommentsPerCommand: {
+		description:  "If non-zero, the maximum number of comments to split command output into before truncating.",
+		defaultValue: 0,
+	},
 	ParallelPoolSize: {
 		description:  "Max size of the wait group that runs parallel plans and applies (if enabled).",
 		defaultValue: DefaultParallelPoolSize,

runatlantis.io/docs/server-configuration.md

@@ -693,6 +693,18 @@ This is useful when you have many projects and want to keep the pull request cle
 
   Defaults to the atlantis home directory `/home/atlantis/.markdown_templates/` in `/$HOME/.markdown_templates`.
 
+### `--max-comments-per-command`
+  ```bash
+  atlantis server --max-comments-per-command=10
+  # or
+  ATLANTIS_MAX_COMMENTS_PER_COMMAND=10
+  ```
+  When a command's output is large, Atlantis automatically splits it into multiple comments with a maximum size based
+  on the specific VCS. By default, Atlantis will post enough comments to include the full command output. If your
+  command has a huge amount of output (eg, from setting `TF_LOG=debug`), the amount of comments may be enough to make
+  it challenging to read your PR, or it may even cause your VCS to rate limit Atlantis. Set this option to a non-zero
+  number to make Atlantis truncate output after this many comments.
+
 ### `--parallel-apply`
   ```bash
   atlantis server --parallel-apply

server/controllers/github_app_controller.go

@@ -56,7 +56,8 @@ func (g *GithubAppController) ExchangeCode(w http.ResponseWriter, r *http.Reques
 	g.Logger.Debug("Exchanging GitHub app code for app credentials")
 	creds := &vcs.GithubAnonymousCredentials{}
 	config := vcs.GithubConfig{}
-	client, err := vcs.NewGithubClient(g.GithubHostname, creds, config, g.Logger)
+	// This client does not post comments, so we don't need to configure it with maxCommentsPerCommand.
+	client, err := vcs.NewGithubClient(g.GithubHostname, creds, config, 0, g.Logger)
 	if err != nil {
 		g.respond(w, logging.Error, http.StatusInternalServerError, "Failed to exchange code for github app: %s", err)
 		return

server/events/vcs/azuredevops_client.go

@@ -106,7 +106,7 @@ func (g *AzureDevopsClient) CreateComment(repo models.Repo, pullNum int, comment
 	// or tested limit in Azure DevOps.
 	const maxCommentLength = 150000
 
-	comments := common.SplitComment(comment, maxCommentLength, sepEnd, sepStart)
+	comments := common.SplitComment(comment, maxCommentLength, sepEnd, sepStart, 0, "")
 	owner, project, repoName := SplitAzureDevopsRepoFullName(repo.FullName)
 
 	for i := range comments {

server/events/vcs/bitbucketserver/client.go

@@ -136,7 +136,7 @@ func (b *Client) GetProjectKey(repoName string, cloneURL string) (string, error)
 func (b *Client) CreateComment(repo models.Repo, pullNum int, comment string, command string) error {
 	sepEnd := "\n```\n**Warning**: Output length greater than max comment size. Continued in next comment."
 	sepStart := "Continued from previous comment.\n```diff\n"
-	comments := common.SplitComment(comment, maxCommentLength, sepEnd, sepStart)
+	comments := common.SplitComment(comment, maxCommentLength, sepEnd, sepStart, 0, "")
 	for _, c := range comments {
 		if err := b.postComment(repo, pullNum, c); err != nil {
 			return err

server/events/vcs/common/common.go

@@ -15,19 +15,32 @@ func AutomergeCommitMsg(pullNum int) string {
 // SplitComment splits comment into a slice of comments that are under maxSize.
 // It appends sepEnd to all comments that have a following comment.
 // It prepends sepStart to all comments that have a preceding comment.
-func SplitComment(comment string, maxSize int, sepEnd string, sepStart string) []string {
+// If maxCommentsPerCommand is non-zero, it never returns more than maxCommentsPerCommand
+// comments, and it appends truncationFooter to the final comment if it would have
+// produced more comments.
+func SplitComment(comment string, maxSize int, sepEnd string, sepStart string, maxCommentsPerCommand int, truncationFooter string) []string {
 	if len(comment) <= maxSize {
 		return []string{comment}
 	}
 
-	maxWithSep := maxSize - len(sepEnd) - len(sepStart)
+	// No comment contains both sepEnd and truncationFooter, so we only have to count their max.
+	maxWithSep := maxSize - max(len(sepEnd), len(truncationFooter)) - len(sepStart)
 	var comments []string
-	numComments := int(math.Ceil(float64(len(comment)) / float64(maxWithSep)))
+	numPotentialComments := int(math.Ceil(float64(len(comment)) / float64(maxWithSep)))
+	var numComments int
+	if maxCommentsPerCommand == 0 {
+		numComments = numPotentialComments
+	} else {
+		numComments = min(numPotentialComments, maxCommentsPerCommand)
+	}
+
 	for i := 0; i < numComments; i++ {
 		upTo := min(len(comment), (i+1)*maxWithSep)
 		portion := comment[i*maxWithSep : upTo]
 		if i < numComments-1 {
 			portion += sepEnd
+		} else if i == numComments-1 && numComments < numPotentialComments {
+			portion += truncationFooter
 		}
 		if i > 0 {
 			portion = sepStart + portion
@@ -43,3 +56,10 @@ func min(a, b int) int {
 	}
 	return b
 }
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

server/events/vcs/common/common_test.go

@@ -24,7 +24,7 @@ import (
 // If under the maximum number of chars, we shouldn't split the comments.
 func TestSplitComment_UnderMax(t *testing.T) {
 	comment := "comment under max size"
-	split := common.SplitComment(comment, len(comment)+1, "sepEnd", "sepStart")
+	split := common.SplitComment(comment, len(comment)+1, "sepEnd", "sepStart", 0, "")
 	Equals(t, []string{comment}, split)
 }
 
@@ -34,7 +34,7 @@ func TestSplitComment_TwoComments(t *testing.T) {
 	comment := strings.Repeat("a", 1000)
 	sepEnd := "-sepEnd"
 	sepStart := "-sepStart"
-	split := common.SplitComment(comment, len(comment)-1, sepEnd, sepStart)
+	split := common.SplitComment(comment, len(comment)-1, sepEnd, sepStart, 0, "")
 
 	expCommentLen := len(comment) - len(sepEnd) - len(sepStart) - 1
 	expFirstComment := comment[:expCommentLen]
@@ -51,7 +51,7 @@ func TestSplitComment_FourComments(t *testing.T) {
 	sepEnd := "-sepEnd"
 	sepStart := "-sepStart"
 	max := (len(comment) / 4) + len(sepEnd) + len(sepStart)
-	split := common.SplitComment(comment, max, sepEnd, sepStart)
+	split := common.SplitComment(comment, max, sepEnd, sepStart, 0, "")
 
 	expMax := len(comment) / 4
 	Equals(t, []string{
@@ -61,6 +61,23 @@ func TestSplitComment_FourComments(t *testing.T) {
 		sepStart + comment[expMax*3:]}, split)
 }
 
+func TestSplitComment_Limited(t *testing.T) {
+	comment := strings.Repeat("a", 1000)
+	sepEnd := "-sepEnd"
+	sepStart := "-sepStart"
+	truncationFooter := "-truncated"
+	max := (len(comment) / 8) + max(len(sepEnd), len(truncationFooter)) + len(sepStart)
+	split := common.SplitComment(comment, max, sepEnd, sepStart, 5, truncationFooter)
+
+	expMax := len(comment) / 8
+	Equals(t, []string{
+		comment[:expMax] + sepEnd,
+		sepStart + comment[expMax:expMax*2] + sepEnd,
+		sepStart + comment[expMax*2:expMax*3] + sepEnd,
+		sepStart + comment[expMax*3:expMax*4] + sepEnd,
+		sepStart + comment[expMax*4:expMax*5] + truncationFooter}, split)
+}
+
 func TestAutomergeCommitMsg(t *testing.T) {
 	tests := []struct {
 		name    string

server/events/vcs/gh_app_creds_rotator_test.go

@@ -19,7 +19,7 @@ func Test_githubAppTokenRotator_GenerateJob(t *testing.T) {
 	Ok(t, err)
 
 	anonCreds := &vcs.GithubAnonymousCredentials{}
-	anonClient, err := vcs.NewGithubClient(testServer, anonCreds, vcs.GithubConfig{}, logging.NewNoopLogger(t))
+	anonClient, err := vcs.NewGithubClient(testServer, anonCreds, vcs.GithubConfig{}, 0, logging.NewNoopLogger(t))
 	Ok(t, err)
 	tempSecrets, err := anonClient.ExchangeCode("good-code")
 	Ok(t, err)

server/events/vcs/github_client.go

@@ -41,12 +41,13 @@ var (
 
 // GithubClient is used to perform GitHub actions.
 type GithubClient struct {
-	user     string
-	client   *github.Client
-	v4Client *githubv4.Client
-	ctx      context.Context
-	logger   logging.SimpleLogging
-	config   GithubConfig
+	user                  string
+	client                *github.Client
+	v4Client              *githubv4.Client
+	ctx                   context.Context
+	logger                logging.SimpleLogging
+	config                GithubConfig
+	maxCommentsPerCommand int
 }
 
 // GithubAppTemporarySecrets holds app credentials obtained from github after creation.
@@ -77,7 +78,7 @@ type GithubPRReviewSummary struct {
 }
 
 // NewGithubClient returns a valid GitHub client.
-func NewGithubClient(hostname string, credentials GithubCredentials, config GithubConfig, logger logging.SimpleLogging) (*GithubClient, error) {
+func NewGithubClient(hostname string, credentials GithubCredentials, config GithubConfig, maxCommentsPerCommand int, logger logging.SimpleLogging) (*GithubClient, error) {
 	transport, err := credentials.Client()
 	if err != nil {
 		return nil, errors.Wrap(err, "error initializing github authentication transport")
@@ -107,12 +108,13 @@ func NewGithubClient(hostname string, credentials GithubCredentials, config Gith
 		return nil, errors.Wrap(err, "getting user")
 	}
 	return &GithubClient{
-		user:     user,
-		client:   client,
-		v4Client: v4Client,
-		ctx:      context.Background(),
-		logger:   logger,
-		config:   config,
+		user:                  user,
+		client:                client,
+		v4Client:              v4Client,
+		ctx:                   context.Background(),
+		logger:                logger,
+		config:                config,
+		maxCommentsPerCommand: maxCommentsPerCommand,
 	}, nil
 }
 
@@ -187,7 +189,10 @@ func (g *GithubClient) CreateComment(repo models.Repo, pullNum int, comment stri
 			"```diff\n"
 	}
 
-	comments := common.SplitComment(comment, maxCommentLength, sepEnd, sepStart)
+	truncationFooter := "\n```\n</details>" +
+		"\n<br>\n\n**Warning**: Command output is larger than the maximum number of comments per command. Output truncated."
+
+	comments := common.SplitComment(comment, maxCommentLength, sepEnd, sepStart, g.maxCommentsPerCommand, truncationFooter)
 	for i := range comments {
 		_, resp, err := g.client.Issues.CreateComment(g.ctx, repo.Owner, repo.Name, pullNum, &github.IssueComment{Body: &comments[i]})
 		g.logger.Debug("POST /repos/%v/%v/issues/%d/comments returned: %v", repo.Owner, repo.Name, pullNum, resp.StatusCode)

server/events/vcs/github_client_internal_test.go

@@ -22,14 +22,14 @@ import (
 
 // If the hostname is github.com, should use normal BaseURL.
 func TestNewGithubClient_GithubCom(t *testing.T) {
-	client, err := NewGithubClient("github.com", &GithubUserCredentials{"user", "pass"}, GithubConfig{}, logging.NewNoopLogger(t))
+	client, err := NewGithubClient("github.com", &GithubUserCredentials{"user", "pass"}, GithubConfig{}, 0, logging.NewNoopLogger(t))
 	Ok(t, err)
 	Equals(t, "https://api.github.com/", client.client.BaseURL.String())
 }
 
 // If the hostname is a non-github hostname should use the right BaseURL.
 func TestNewGithubClient_NonGithub(t *testing.T) {
-	client, err := NewGithubClient("example.com", &GithubUserCredentials{"user", "pass"}, GithubConfig{}, logging.NewNoopLogger(t))
+	client, err := NewGithubClient("example.com", &GithubUserCredentials{"user", "pass"}, GithubConfig{}, 0, logging.NewNoopLogger(t))
 	Ok(t, err)
 	Equals(t, "https://example.com/api/v3/", client.client.BaseURL.String())
 	// If possible in the future, test the GraphQL client's URL as well. But at the