Merge branch 'main' into otel/validate

Author: michalpristas

.buildkite/scripts/steps/integration_tests.sh

@@ -11,7 +11,7 @@ MAGE_SUBTARGET="${3:-""}"
 # Override the agent package version using a string with format <major>.<minor>.<patch>
 # NOTE: use only after version bump when the new version is not yet available, for example:
 # OVERRIDE_AGENT_PACKAGE_VERSION="8.10.3" otherwise OVERRIDE_AGENT_PACKAGE_VERSION="".
-OVERRIDE_AGENT_PACKAGE_VERSION="8.12.0"
+OVERRIDE_AGENT_PACKAGE_VERSION=""
 
 if [[ -n "$OVERRIDE_AGENT_PACKAGE_VERSION" ]]; then
   OVERRIDE_TEST_AGENT_VERSION=${OVERRIDE_AGENT_PACKAGE_VERSION}"-SNAPSHOT"

internal/pkg/agent/application/upgrade/details/details.go

@@ -5,6 +5,7 @@
 package details
 
 import (
+	"math"
 	"sync"
 	"time"
 
@@ -93,7 +94,17 @@ func (d *Details) SetDownloadProgress(percent, rateBytesPerSecond float64) {
 	defer d.mu.Unlock()
 
 	d.Metadata.DownloadPercent = percent
-	d.Metadata.DownloadRate = details.DownloadRate(rateBytesPerSecond)
+
+	// A download rate of +Inf is possible if the download completes near instantaneously. Since
+	// +Inf (or -Inf or NaN) are not indexable into Elasticsearch or generally informative since the
+	// download percent is 100% when this happens, just reset download rate to the default value of
+	// zero when this happens. https://github.com/elastic/elastic-agent/issues/4041
+	if math.IsInf(rateBytesPerSecond, 0) || math.IsNaN(rateBytesPerSecond) {
+		d.Metadata.DownloadRate = 0
+	} else {
+		d.Metadata.DownloadRate = details.DownloadRate(rateBytesPerSecond)
+	}
+
 	d.notifyObservers()
 }
 

internal/pkg/agent/application/upgrade/details/details_test.go

@@ -71,33 +71,32 @@ func TestDetailsObserver(t *testing.T) {
 func TestDetailsDownloadRateJSON(t *testing.T) {
 	det := NewDetails("99.999.9999", StateRequested, "test_action_id")
 
-	// Normal (non-infinity) download rate
-	t.Run("non_infinity", func(t *testing.T) {
-		det.SetDownloadProgress(.8, 1794.7)
-
-		data, err := json.Marshal(det)
-		require.NoError(t, err)
-
-		var unmarshalledDetails Details
-		err = json.Unmarshal(data, &unmarshalledDetails)
-		require.NoError(t, err)
-		require.Equal(t, float64(1794), float64(unmarshalledDetails.Metadata.DownloadRate))
-		require.Equal(t, .8, unmarshalledDetails.Metadata.DownloadPercent)
-	})
-
-	// Infinity download rate
-	t.Run("infinity", func(t *testing.T) {
-		det.SetDownloadProgress(0.99, math.Inf(1))
-
-		data, err := json.Marshal(det)
-		require.NoError(t, err)
-
-		var unmarshalledDetails Details
-		err = json.Unmarshal(data, &unmarshalledDetails)
-		require.NoError(t, err)
-		require.Equal(t, math.Inf(1), float64(unmarshalledDetails.Metadata.DownloadRate))
-		require.Equal(t, 0.99, unmarshalledDetails.Metadata.DownloadPercent)
-	})
+	tests := []struct {
+		name     string
+		percent  float64
+		rate_in  float64
+		rate_out float64
+	}{
+		{"non_infinity", .8, 1794.7, 1794},
+		{"positive_infinity", 0.99, math.Inf(1), 0},
+		{"negative_infinity", 0.99, math.Inf(-1), 0},
+		{"not_a_number", 0.99, math.NaN(), 0},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			det.SetDownloadProgress(tc.percent, tc.rate_in)
+
+			data, err := json.Marshal(det)
+			require.NoError(t, err)
+
+			var unmarshalledDetails Details
+			err = json.Unmarshal(data, &unmarshalledDetails)
+			require.NoError(t, err)
+			require.Equal(t, tc.rate_out, float64(unmarshalledDetails.Metadata.DownloadRate))
+			require.Equal(t, tc.percent, unmarshalledDetails.Metadata.DownloadPercent)
+		})
+	}
 }
 
 func TestEquals(t *testing.T) {

internal/pkg/agent/cmd/run.go

@@ -501,6 +501,10 @@ func tryDelayEnroll(ctx context.Context, logger *logger.Logger, cfg *configurati
 	}
 	options.DelayEnroll = false
 	options.FleetServer.SpawnAgent = false
+	// enrollCmd daemonReloadWithBackoff is broken
+	// see https://github.com/elastic/elastic-agent/issues/4043
+	// SkipDaemonRestart to true avoids running that code.
+	options.SkipDaemonRestart = true
 	c, err := newEnrollCmd(
 		ctx,
 		logger,

pkg/testing/fixture_install.go

@@ -58,6 +58,7 @@ type InstallOpts struct {
 	NonInteractive bool   // --non-interactive
 	ProxyURL       string // --proxy-url
 	Unprivileged   bool   // --unprivileged
+	DelayEnroll    bool   // --delay-enroll
 
 	EnrollOpts
 }
@@ -82,6 +83,9 @@ func (i InstallOpts) toCmdArgs() []string {
 	if i.Unprivileged {
 		args = append(args, "--unprivileged")
 	}
+	if i.DelayEnroll {
+		args = append(args, "--delay-enroll")
+	}
 
 	args = append(args, i.EnrollOpts.toCmdArgs()...)
 

pkg/testing/tools/tools.go

@@ -123,6 +123,11 @@ func InstallAgentForPolicy(ctx context.Context, t *testing.T,
 		timeout = time.Until(deadline)
 	}
 
+	// Don't check fleet status if --delay-enroll
+	if installOpts.DelayEnroll {
+		return nil
+	}
+
 	// Wait for Agent to be healthy
 	require.Eventually(
 		t,

testing/integration/delay_enroll_test.go

@@ -0,0 +1,86 @@
+// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+// or more contributor license agreements. Licensed under the Elastic License;
+// you may not use this file except in compliance with the Elastic License.
+
+//go:build integration
+
+package integration
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/elastic/elastic-agent-libs/kibana"
+	atesting "github.com/elastic/elastic-agent/pkg/testing"
+	"github.com/elastic/elastic-agent/pkg/testing/define"
+	"github.com/elastic/elastic-agent/pkg/testing/tools"
+	"github.com/elastic/elastic-agent/pkg/testing/tools/check"
+	"github.com/elastic/elastic-agent/pkg/testing/tools/testcontext"
+)
+
+func TestDelayEnroll(t *testing.T) {
+	info := define.Require(t, define.Requirements{
+		Group: Fleet,
+		Stack: &define.Stack{},
+		Local: false,
+		Sudo:  true,
+		OS:    []define.OS{{Type: define.Linux}},
+	})
+
+	ctx, cancel := testcontext.WithDeadline(t, context.Background(), time.Now().Add(10*time.Minute))
+	defer cancel()
+
+	agentFixture, err := define.NewFixture(t, define.Version())
+	require.NoError(t, err)
+
+	// 1. Create a policy in Fleet with monitoring enabled.
+	// To ensure there are no conflicts with previous test runs against
+	// the same ESS stack, we add the current time at the end of the policy
+	// name. This policy does not contain any integration.
+	t.Log("Enrolling agent in Fleet with a test policy")
+	createPolicyReq := kibana.AgentPolicy{
+		Name:        fmt.Sprintf("test-policy-enroll-%d", time.Now().Unix()),
+		Namespace:   info.Namespace,
+		Description: "test policy for agent enrollment",
+		MonitoringEnabled: []kibana.MonitoringEnabledOption{
+			kibana.MonitoringEnabledLogs,
+			kibana.MonitoringEnabledMetrics,
+		},
+		AgentFeatures: []map[string]interface{}{
+			{
+				"name":    "test_enroll",
+				"enabled": true,
+			},
+		},
+	}
+
+	installOpts := atesting.InstallOpts{
+		NonInteractive: true,
+		Force:          true,
+		DelayEnroll:    true,
+	}
+	// Install the Elastic-Agent with the policy that was just
+	// created.
+	_, err = tools.InstallAgentWithPolicy(
+		ctx,
+		t,
+		installOpts,
+		agentFixture,
+		info.KibanaClient,
+		createPolicyReq)
+	require.NoError(t, err)
+
+	// Start elastic-agent via service, this should do the enrollment
+	cmd := exec.Command("/usr/bin/systemctl", "start", "elastic-agent")
+	stdErrStdout, err := cmd.CombinedOutput()
+	require.NoErrorf(t, err, "systemctl start elastic-agent output was %s", stdErrStdout)
+
+	// check to make sure enroll worked
+	check.ConnectedToFleet(ctx, t, agentFixture, 5*time.Minute)
+
+}