[mongodbatlasreceiver] Add baseURL config

.chloggen/feat--Add-support-for-atlasgov.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: mongodbatlasreceiver
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: "Add support for setting custom base URL for the MongoDB Atlas API"
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [39345]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user]

receiver/mongodbatlasreceiver/README.md

@@ -34,6 +34,7 @@ In order to collect access logs, the requesting API key needs the appropriate pe
 
 MongoDB Atlas [Documentation](https://www.mongodb.com/docs/atlas/reference/api/logs/#logs) recommends a polling interval of 5 minutes.
 
+- `base_url` (default https://cloud.mongodb.com/) set the base URL to connect to to Atlas Cloud
 - `public_key` (required for metrics, logs, or alerts in `poll` mode)
 - `private_key` (required for metrics, logs, or alerts in `poll` mode)
 - `granularity` (default `PT1M` - See [MongoDB Atlas Documentation](https://docs.atlas.mongodb.com/reference/api/process-measurements/))

receiver/mongodbatlasreceiver/access_logs.go

@@ -53,10 +53,15 @@ type accessLogsReceiver struct {
 	cancel     context.CancelFunc
 }
 
-func newAccessLogsReceiver(settings rcvr.Settings, cfg *Config, consumer consumer.Logs) *accessLogsReceiver {
+func newAccessLogsReceiver(settings rcvr.Settings, cfg *Config, consumer consumer.Logs) (*accessLogsReceiver, error) {
+	client, err := internal.NewMongoDBAtlasClient(cfg.BaseURL, cfg.PublicKey, string(cfg.PrivateKey), cfg.BackOffConfig, settings.Logger)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create MongoDB Atlas client for access logs receiver: %w", err)
+	}
+
 	r := &accessLogsReceiver{
 		cancel:        func() {},
-		client:        internal.NewMongoDBAtlasClient(cfg.PublicKey, string(cfg.PrivateKey), cfg.BackOffConfig, settings.Logger),
+		client:        client,
 		cfg:           cfg,
 		logger:        settings.Logger,
 		consumer:      consumer,
@@ -80,7 +85,7 @@ func newAccessLogsReceiver(settings rcvr.Settings, cfg *Config, consumer consume
 		}
 	}
 
-	return r
+	return r, nil
 }
 
 func (alr *accessLogsReceiver) Start(ctx context.Context, _ component.Host, storageClient storage.Client) error {

receiver/mongodbatlasreceiver/access_logs_test.go

@@ -277,7 +277,8 @@ func TestAccessLogsRetrieval(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			logSink := &consumertest.LogsSink{}
-			rcvr := newAccessLogsReceiver(receivertest.NewNopSettings(metadata.Type), tc.config(), logSink)
+			rcvr, e := newAccessLogsReceiver(receivertest.NewNopSettings(metadata.Type), tc.config(), logSink)
+			require.NoError(t, e)
 			tc.setup(rcvr)
 
 			err := rcvr.Start(context.Background(), componenttest.NewNopHost(), storage.NewNopClient())
@@ -314,7 +315,8 @@ func TestCheckpointing(t *testing.T) {
 	}
 
 	logSink := &consumertest.LogsSink{}
-	rcvr := newAccessLogsReceiver(receivertest.NewNopSettings(metadata.Type), config, logSink)
+	rcvr, e := newAccessLogsReceiver(receivertest.NewNopSettings(metadata.Type), config, logSink)
+	require.NoError(t, e)
 	rcvr.client = simpleAccessLogClient()
 
 	// First cluster checkpoint should be nil

receiver/mongodbatlasreceiver/alerts.go

@@ -71,6 +71,7 @@ type alertsReceiver struct {
 	// only relevant in `poll` mode
 	projects          []*ProjectConfig
 	client            alertsClient
+	baseURL           string
 	privateKey        string
 	publicKey         string
 	backoffConfig     configretry.BackOffConfig
@@ -108,6 +109,7 @@ func newAlertsReceiver(params rcvr.Settings, baseConfig *Config, consumer consum
 		mode:              cfg.Mode,
 		projects:          cfg.Projects,
 		backoffConfig:     baseConfig.BackOffConfig,
+		baseURL:           baseConfig.BaseURL,
 		publicKey:         baseConfig.PublicKey,
 		privateKey:        string(baseConfig.PrivateKey),
 		wg:                &sync.WaitGroup{},
@@ -119,7 +121,12 @@ func newAlertsReceiver(params rcvr.Settings, baseConfig *Config, consumer consum
 	}
 
 	if recv.mode == alertModePoll {
-		recv.client = internal.NewMongoDBAtlasClient(recv.publicKey, recv.privateKey, recv.backoffConfig, recv.telemetrySettings.Logger)
+		client, err := internal.NewMongoDBAtlasClient(recv.baseURL, recv.publicKey, recv.privateKey, recv.backoffConfig, recv.telemetrySettings.Logger)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create MongoDB Atlas client for alerts receiver: %w", err)
+		}
+
+		recv.client = client
 		return recv, nil
 	}
 	s := &http.Server{

receiver/mongodbatlasreceiver/config.go

@@ -7,9 +7,11 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"net/url"
 	"strings"
 	"time"
 
+	"go.mongodb.org/atlas/mongodbatlas"
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/config/configopaque"
 	"go.opentelemetry.io/collector/config/configretry"
@@ -24,6 +26,7 @@ var _ component.Config = (*Config)(nil)
 
 type Config struct {
 	scraperhelper.ControllerConfig `mapstructure:",squash"`
+	BaseURL                        string                        `mapstructure:"base_url"`
 	PublicKey                      string                        `mapstructure:"public_key"`
 	PrivateKey                     configopaque.String           `mapstructure:"private_key"`
 	Granularity                    string                        `mapstructure:"granularity"`
@@ -129,11 +132,22 @@ var (
 
 	// Access Logs Errors
 	errMaxPageSize = errors.New("the maximum value for 'page_size' is 20000")
+
+	// Config Errors
+	errConfigEmptyEndpoint = errors.New("baseurl must not be empty")
 )
 
 func (c *Config) Validate() error {
 	var errs error
 
+	if c.BaseURL == "" {
+		c.BaseURL = mongodbatlas.CloudURL
+	}
+
+	if err := validateEndpoint(c.BaseURL); err != nil {
+		return fmt.Errorf("invalid base_url %q: %w", c.BaseURL, err)
+	}
+
 	for _, project := range c.Projects {
 		if len(project.ExcludeClusters) != 0 && len(project.IncludeClusters) != 0 {
 			errs = multierr.Append(errs, errClusterConfig)
@@ -243,3 +257,23 @@ func (e EventsConfig) validate() error {
 	}
 	return nil
 }
+
+func validateEndpoint(endpoint string) error {
+	if endpoint == "" {
+		return errConfigEmptyEndpoint
+	}
+
+	u, err := url.Parse(endpoint)
+	if err != nil {
+		return err
+	}
+	switch u.Scheme {
+	case "http", "https":
+	default:
+		return fmt.Errorf(`invalid scheme %q, expected "http" or "https"`, u.Scheme)
+	}
+	if u.Host == "" {
+		return errors.New("host must not be empty")
+	}
+	return nil
+}

receiver/mongodbatlasreceiver/config_test.go

@@ -361,6 +361,7 @@ func TestLoadConfig(t *testing.T) {
 
 	expected := factory.CreateDefaultConfig().(*Config)
 	expected.MetricsBuilderConfig = metadata.DefaultMetricsBuilderConfig()
+	expected.BaseURL = "https://cloud.mongodb.com/"
 	expected.PrivateKey = "my-private-key"
 	expected.PublicKey = "my-public-key"
 	expected.Logs = LogConfig{

receiver/mongodbatlasreceiver/events.go

@@ -57,9 +57,14 @@ type eventRecord struct {
 	NextStartTime *time.Time `mapstructure:"next_start_time"`
 }
 
-func newEventsReceiver(settings rcvr.Settings, c *Config, consumer consumer.Logs) *eventsReceiver {
+func newEventsReceiver(settings rcvr.Settings, c *Config, consumer consumer.Logs) (*eventsReceiver, error) {
+	client, err := internal.NewMongoDBAtlasClient(c.BaseURL, c.PublicKey, string(c.PrivateKey), c.BackOffConfig, settings.Logger)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create MongoDB Atlas client for events receiver: %w", err)
+	}
+
 	r := &eventsReceiver{
-		client:        internal.NewMongoDBAtlasClient(c.PublicKey, string(c.PrivateKey), c.BackOffConfig, settings.Logger),
+		client:        client,
 		cfg:           c,
 		logger:        settings.Logger,
 		consumer:      consumer,
@@ -82,7 +87,7 @@ func newEventsReceiver(settings rcvr.Settings, c *Config, consumer consumer.Logs
 		r.pollInterval = time.Minute
 	}
 
-	return r
+	return r, nil
 }
 
 func (er *eventsReceiver) Start(ctx context.Context, _ component.Host, storageClient storage.Client) error {

receiver/mongodbatlasreceiver/events_test.go

@@ -53,7 +53,8 @@ func TestStartAndShutdown(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
 			sink := &consumertest.LogsSink{}
-			r := newEventsReceiver(receivertest.NewNopSettings(metadata.Type), tc.getConfig(), sink)
+			r, e := newEventsReceiver(receivertest.NewNopSettings(metadata.Type), tc.getConfig(), sink)
+			require.NoError(t, e)
 			err := r.Start(context.Background(), componenttest.NewNopHost(), storage.NewNopClient())
 			if tc.expectedStartErr != nil {
 				require.ErrorContains(t, err, tc.expectedStartErr.Error())
@@ -80,7 +81,10 @@ func TestContextDone(t *testing.T) {
 		},
 	}
 	sink := &consumertest.LogsSink{}
-	r := newEventsReceiver(receivertest.NewNopSettings(metadata.Type), cfg, sink)
+	r, er := newEventsReceiver(receivertest.NewNopSettings(metadata.Type), cfg, sink)
+	if er != nil {
+		t.Fatalf("failed to create receiver: %v", er)
+	}
 	r.pollInterval = 500 * time.Millisecond
 	mClient := &mockEventsClient{}
 	mClient.setupMock(t)
@@ -116,7 +120,8 @@ func TestPoll(t *testing.T) {
 	}
 
 	sink := &consumertest.LogsSink{}
-	r := newEventsReceiver(receivertest.NewNopSettings(metadata.Type), cfg, sink)
+	r, e := newEventsReceiver(receivertest.NewNopSettings(metadata.Type), cfg, sink)
+	require.NoError(t, e)
 	mClient := &mockEventsClient{}
 	mClient.setupMock(t)
 	r.client = mClient
@@ -161,7 +166,8 @@ func TestProjectGetFailure(t *testing.T) {
 	}
 
 	sink := &consumertest.LogsSink{}
-	r := newEventsReceiver(receivertest.NewNopSettings(metadata.Type), cfg, sink)
+	r, e := newEventsReceiver(receivertest.NewNopSettings(metadata.Type), cfg, sink)
+	require.NoError(t, e)
 	mClient := &mockEventsClient{}
 	mClient.On("GetProject", mock.Anything, "fake-project").Return(nil, fmt.Errorf("unable to get project: %d", http.StatusUnauthorized))
 	mClient.On("GetOrganization", mock.Anything, "fake-org").Return(nil, fmt.Errorf("unable to get org: %d", http.StatusUnauthorized))

receiver/mongodbatlasreceiver/factory.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"time"
 
+	"go.mongodb.org/atlas/mongodbatlas"
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/config/configretry"
 	"go.opentelemetry.io/collector/consumer"
@@ -40,7 +41,10 @@ func createMetricsReceiver(
 	consumer consumer.Metrics,
 ) (receiver.Metrics, error) {
 	cfg := rConf.(*Config)
-	recv := newMongoDBAtlasReceiver(params, cfg)
+	recv, err := newMongoDBAtlasReceiver(params, cfg)
+	if err != nil {
+		return nil, fmt.Errorf("unable to create a MongoDB Atlas Receiver instance: %w", err)
+	}
 	ms, err := newMongoDBAtlasScraper(recv)
 	if err != nil {
 		return nil, fmt.Errorf("unable to create a MongoDB Atlas Scraper instance: %w", err)
@@ -75,25 +79,35 @@ func createCombinedLogReceiver(
 	}
 
 	if cfg.Logs.Enabled {
-		recv.logs = newMongoDBAtlasLogsReceiver(params, cfg, consumer)
+		recv.logs, err = newMongoDBAtlasLogsReceiver(params, cfg, consumer)
+		if err != nil {
+			return nil, fmt.Errorf("unable to create a MongoDB Atlas Logs Receiver instance: %w", err)
+		}
 		// Confirm at least one project is enabled for access logs before adding
 		for _, project := range cfg.Logs.Projects {
 			if project.AccessLogs != nil && project.AccessLogs.IsEnabled() {
-				recv.accessLogs = newAccessLogsReceiver(params, cfg, consumer)
+				recv.accessLogs, err = newAccessLogsReceiver(params, cfg, consumer)
+				if err != nil {
+					return nil, fmt.Errorf("unable to create a MongoDB Atlas Access Logs Receiver instance: %w", err)
+				}
 				break
 			}
 		}
 	}
 
 	if cfg.Events != nil {
-		recv.events = newEventsReceiver(params, cfg, consumer)
+		recv.events, err = newEventsReceiver(params, cfg, consumer)
+		if err != nil {
+			return nil, fmt.Errorf("unable to create a MongoDB Atlas Events Receiver instance: %w", err)
+		}
 	}
 
 	return recv, nil
 }
 
 func createDefaultConfig() component.Config {
 	c := &Config{
+		BaseURL:              mongodbatlas.CloudURL,
 		ControllerConfig:     scraperhelper.NewDefaultControllerConfig(),
 		Granularity:          defaultGranularity,
 		BackOffConfig:        configretry.NewDefaultBackOffConfig(),

receiver/mongodbatlasreceiver/internal/mongodb_atlas_client.go

@@ -130,22 +130,32 @@ type MongoDBAtlasClient struct {
 
 // NewMongoDBAtlasClient creates a new MongoDB Atlas client wrapper
 func NewMongoDBAtlasClient(
+	baseURL string,
 	publicKey string,
 	privateKey string,
 	backoffConfig configretry.BackOffConfig,
 	log *zap.Logger,
-) *MongoDBAtlasClient {
+) (*MongoDBAtlasClient, error) {
 	defaultTransporter := http.DefaultTransport.(*http.Transport)
 	t := digest.NewTransportWithHTTPTransport(publicKey, privateKey, defaultTransporter)
 	roundTripper := newClientRoundTripper(t, log, backoffConfig)
 	tc := &http.Client{Transport: roundTripper}
-	client := mongodbatlas.NewClient(tc)
+
+	if baseURL == "" {
+		baseURL = mongodbatlas.CloudURL
+	}
+
+	client, err := mongodbatlas.New(tc, mongodbatlas.SetBaseURL(baseURL))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create MongoDB Atlas client: %w", err)
+	}
+
 	return &MongoDBAtlasClient{
 		log,
 		client,
 		defaultTransporter,
 		roundTripper,
-	}
+	}, nil
 }
 
 func (s *MongoDBAtlasClient) Shutdown() error {

receiver/mongodbatlasreceiver/logs.go

@@ -6,6 +6,7 @@ package mongodbatlasreceiver // import "github.com/open-telemetry/opentelemetry-
 import (
 	"context"
 	"errors"
+	"fmt"
 	"io"
 	"net"
 	"strings"
@@ -43,8 +44,11 @@ type projectContext struct {
 // MongoDB Atlas Documentation recommends a polling interval of 5 minutes: https://www.mongodb.com/docs/atlas/reference/api/logs/#logs
 const collectionInterval = time.Minute * 5
 
-func newMongoDBAtlasLogsReceiver(settings rcvr.Settings, cfg *Config, consumer consumer.Logs) *logsReceiver {
-	client := internal.NewMongoDBAtlasClient(cfg.PublicKey, string(cfg.PrivateKey), cfg.BackOffConfig, settings.Logger)
+func newMongoDBAtlasLogsReceiver(settings rcvr.Settings, cfg *Config, consumer consumer.Logs) (*logsReceiver, error) {
+	client, err := internal.NewMongoDBAtlasClient(cfg.BaseURL, cfg.PublicKey, string(cfg.PrivateKey), cfg.BackOffConfig, settings.Logger)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create MongoDB Atlas client for logs receiver: %w", err)
+	}
 
 	for _, p := range cfg.Logs.Projects {
 		p.populateIncludesAndExcludes()
@@ -56,7 +60,7 @@ func newMongoDBAtlasLogsReceiver(settings rcvr.Settings, cfg *Config, consumer c
 		client:      client,
 		stopperChan: make(chan struct{}),
 		consumer:    consumer,
-	}
+	}, nil
 }
 
 // Log receiver logic