internal/output/webhook: add server probe configuration (#153)

Setting the STREAM_PROBE env var or the webhook-probe options can now be
used to modify the behaviour of the webhook output to choose whether to
perform an initial server probe and which method to use in the probe.

* empty/unset, 1, true or HEAD: current behaviour
* 0, false: no probe
* GET, CONNECT, OPTIONS, PATCH, POST and PUT: an empty-bodied request
  using that method.

Author: efd6

.changelog/153.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+webhook output: Add support for server probing behavior configuration.
+```

internal/command/root.go

@@ -75,6 +75,7 @@ func ExecuteContext(ctx context.Context) error {
 	rootCmd.PersistentFlags().StringVar(&opts.WebhookOptions.Password, "webhook-password", "", "webhook password for basic authentication")
 	rootCmd.PersistentFlags().StringVar(&opts.WebhookOptions.Username, "webhook-username", "", "webhook username for basic authentication")
 	rootCmd.PersistentFlags().DurationVar(&opts.WebhookOptions.Timeout, "webhook-timeout", time.Second, "webhook request timeout (zero is no timeout)")
+	rootCmd.PersistentFlags().StringVar(&opts.WebhookOptions.Probe, "webhook-probe", "", "webhook server probe request method (''/1/true/HEAD, CONNECT, GET, ..., or 0/false for no probe)")
 
 	// GCP Pubsub output flags.
 	rootCmd.PersistentFlags().StringVar(&opts.GCPPubsubOptions.Project, "gcppubsub-project", "test", "GCP Pubsub project name")

internal/output/options.go

@@ -31,6 +31,7 @@ type WebhookOptions struct {
 	Username    string        // Basic auth username.
 	Password    string        // Basic auth password.
 	Timeout     time.Duration // Timeout for request handling.
+	Probe       string        // Server probe behavior.
 }
 
 type GCPPubsubOptions struct {

internal/output/webhook/webhook.go

@@ -47,8 +47,22 @@ func New(opts *output.Options) (output.Output, error) {
 }
 
 func (o *Output) DialContext(ctx context.Context) error {
-	// Use a HEAD request to check if the service is ready.
-	req, err := http.NewRequestWithContext(ctx, http.MethodHead, o.opts.Addr, nil)
+	method := o.opts.WebhookOptions.Probe
+	switch method {
+	case "", "1", "true", http.MethodHead:
+		// Default behaviour is to do a HEAD probe.
+		method = http.MethodHead
+	case "0", "false":
+		// Don't probe.
+		return nil
+	case http.MethodGet, http.MethodConnect, http.MethodOptions, http.MethodPatch, http.MethodPost, http.MethodPut:
+		// Fall through with the option that the env var specifies.
+	default:
+		return fmt.Errorf("unknown probe behavior option: %q", method)
+	}
+
+	// Use a request to check if the service is ready.
+	req, err := http.NewRequestWithContext(ctx, method, o.opts.Addr, nil)
 	if err != nil {
 		return err
 	}

internal/output/webhook/webhook_test.go

@@ -10,6 +10,7 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -76,3 +77,53 @@ func TestWebhook(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, len(data), n)
 }
+
+func TestWebhookProbe(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		method string
+		probed bool
+		ok     bool
+	}{
+		{name: "unset", method: "", probed: true, ok: false},
+		{name: "true", method: "true", probed: true, ok: false},
+		{name: "HEAD", method: "HEAD", probed: true, ok: false},
+
+		{name: "zero", method: "0", probed: false, ok: true},
+		{name: "false", method: "false", probed: false, ok: true},
+
+		{name: "CONNECT", method: "CONNECT", probed: true, ok: false},
+		{name: "GET", method: "GET", probed: true, ok: false},
+		{name: "OPTIONS", method: "OPTIONS", probed: true, ok: false},
+		{name: "POST", method: "POST", probed: true, ok: true}, // There can be only one.
+		{name: "PUT", method: "PUT", probed: true, ok: false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			var probed atomic.Bool
+			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				probed.Store(true)
+				if test.ok {
+					assert.Equal(t, http.MethodPost, r.Method)
+				} else {
+					assert.NotEqual(t, http.MethodPost, r.Method)
+				}
+			}))
+			defer ts.Close()
+
+			out, err := New(&output.Options{
+				Addr: ts.URL + "/logs",
+				WebhookOptions: output.WebhookOptions{
+					Timeout: time.Second,
+					Probe:   test.method,
+				},
+			})
+			require.NoError(t, err)
+
+			err = out.DialContext(context.Background())
+			require.NoError(t, err)
+
+			assert.Equal(t, test.probed, probed.Load())
+		})
+	}
+
+}