add mockability, make tests work

cmd/commands/start/start.go

@@ -14,36 +14,51 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	collector "go.opentelemetry.io/collector/otelcol"
 )
 
+func SetupAndGenerateCollectorSettings() (*collector.CollectorSettings, func(), error) {
+	ctx := logger.WithCtx(context.Background(), logger.Get())
+	// Set Env Vars from config
+	err := config.SetEnvVars()
+	if err != nil {
+		return nil, nil, err
+	}
+	// Set up our temp dir annd temp config files
+	tmpDir, err := os.MkdirTemp("", connections.TempFilesFolder)
+	if err != nil {
+		return nil, nil, err
+	}
+	configFilePaths, overridePath, err := config.GetAllOtelConfigFilePaths(ctx, tmpDir)
+	cleanup := func() {
+		if overridePath != "" {
+			os.Remove(overridePath)
+		}
+		os.RemoveAll(tmpDir)
+	}
+	if err != nil {
+		cleanup()
+		return nil, nil, err
+	}
+	// Generate collector settings with all config files
+	colSettings := observeotel.GenerateCollectorSettings(configFilePaths)
+	return colSettings, cleanup, nil
+}
+
 var startCmd = &cobra.Command{
 	Use:   "start",
 	Short: "Start the Observe agent process.",
 	Long: `The Observe agent is based on the OpenTelemetry Collector. 
 This command reads in the local config and env vars and starts the 
 collector on the current host.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		ctx := logger.WithCtx(context.Background(), logger.Get())
-		// Set Env Vars from config
-		err := config.SetEnvVars()
+		colSettings, cleanup, err := SetupAndGenerateCollectorSettings()
 		if err != nil {
 			return err
 		}
-		// Set up our temp dir annd temp config files
-		tmpDir, err := os.MkdirTemp("", connections.TempFilesFolder)
-		if err != nil {
-			return err
-		}
-		defer os.RemoveAll(tmpDir)
-		configFilePaths, overridePath, err := config.GetAllOtelConfigFilePaths(ctx, tmpDir)
-		if err != nil {
-			return err
-		}
-		if overridePath != "" {
-			defer os.Remove(overridePath)
+		if cleanup != nil {
+			defer cleanup()
 		}
-		// Generate collector settings with all config files
-		colSettings := observeotel.GenerateCollectorSettings(configFilePaths)
 		otelCmd := observeotel.GetOtelCollectorCommand(colSettings)
 		return otelCmd.RunE(cmd, args)
 	},

cmd/commands/util/logger.go

@@ -13,6 +13,11 @@ func Get() *zap.Logger {
 	return logger
 }
 
+func GetDev() *zap.Logger {
+	logger, _ := zap.NewDevelopment()
+	return logger
+}
+
 func FromCtx(ctx context.Context) *zap.Logger {
 	if l, ok := ctx.Value(ctxKey{}).(*zap.Logger); ok {
 		return l

cmd/config/confighandler.go

@@ -20,7 +20,11 @@ func GetAllOtelConfigFilePaths(ctx context.Context, tmpDir string) ([]string, st
 	// Get additional config paths based on connection configs
 	for _, conn := range connections.AllConnectionTypes {
 		if viper.IsSet(conn.Name) {
-			configFilePaths = append(configFilePaths, conn.GetConfigFilePaths(ctx, tmpDir)...)
+			connectionPaths, err := conn.GetConfigFilePaths(ctx, tmpDir)
+			if err != nil {
+				return nil, "", err
+			}
+			configFilePaths = append(configFilePaths, connectionPaths...)
 		}
 	}
 	// Read in otel-config flag and add to paths if set

cmd/connections/connections.go

@@ -28,6 +28,9 @@ type ConnectionType struct {
 	Name         string
 	ConfigFields []CollectorConfigFragment
 	Type         string
+
+	configFolderPath string
+	getConfig        func() *viper.Viper
 }
 
 func GetConfigFolderPath() string {
@@ -48,24 +51,24 @@ func GetConfigFolderPath() string {
 }
 
 func (c *ConnectionType) GetTemplateFilepath(tplFilename string) string {
-	return filepath.Join(GetConfigFolderPath(), c.Name, tplFilename)
+	return filepath.Join(c.configFolderPath, c.Name, tplFilename)
 }
 
 func (c *ConnectionType) RenderConfigTemplate(ctx context.Context, tmpDir string, tplFilename string, confValues any) (string, error) {
 	tplPath := c.GetTemplateFilepath(tplFilename)
-	tmpl, err := template.ParseFiles(tplPath)
+	tmpl, err := template.New("").Funcs(GetTemplateFuncMap()).ParseFiles(tplPath)
 	if err != nil {
 		logger.FromCtx(ctx).Error("failed to parse config fragment template", zap.String("file", tplPath), zap.Error(err))
 		return "", err
 	}
 	f, err := os.CreateTemp(tmpDir, fmt.Sprintf("*-%s", tplFilename))
 	if err != nil {
-		logger.FromCtx(ctx).Error("failed to create temporary config fragment file", zap.Error(err))
+		logger.FromCtx(ctx).Error("failed to create temporary config fragment file", zap.String("file", tplPath), zap.Error(err))
 		return "", err
 	}
-	err = tmpl.Execute(f, confValues)
+	err = tmpl.ExecuteTemplate(f, tplFilename, confValues)
 	if err != nil {
-		logger.FromCtx(ctx).Error("failed to execute config fragment template", zap.Error(err))
+		logger.FromCtx(ctx).Error("failed to execute config fragment template", zap.String("file", tplPath), zap.Error(err))
 		return "", err
 	}
 	return f.Name(), nil
@@ -76,40 +79,82 @@ func (c *ConnectionType) ProcessConfigFields(ctx context.Context, tmpDir string,
 	for _, field := range c.ConfigFields {
 		val := rawConnConfig.GetBool(field.configYAMLPath)
 		if val && field.colConfigFilePath != "" {
-			configPath, _ := c.RenderConfigTemplate(ctx, tmpDir, field.colConfigFilePath, confValues)
+			configPath, err := c.RenderConfigTemplate(ctx, tmpDir, field.colConfigFilePath, confValues)
+			if err != nil {
+				return nil, err
+			}
 			paths = append(paths, configPath)
 		}
 	}
 	return paths, nil
 }
 
-func (c *ConnectionType) GetConfigFilePaths(ctx context.Context, tmpDir string) []string {
-	var rawConnConfig = viper.Sub(c.Name)
+func (c *ConnectionType) GetConfigFilePaths(ctx context.Context, tmpDir string) ([]string, error) {
+	var rawConnConfig = c.getConfig()
 	var configPaths []string
 	if rawConnConfig == nil || !rawConnConfig.GetBool("enabled") {
-		return configPaths
+		return configPaths, nil
 	}
 	switch c.Type {
 	case SelfMonitoringConnectionTypeName:
 		conf := &SelfMonitoringConfig{}
 		err := rawConnConfig.Unmarshal(conf)
 		if err != nil {
 			logger.FromCtx(ctx).Error("failed to unmarshal config", zap.String("connection", c.Name))
+			return nil, err
+		}
+		configPaths, err = c.ProcessConfigFields(ctx, tmpDir, rawConnConfig, conf)
+		if err != nil {
+			return nil, err
 		}
-		configPaths, _ = c.ProcessConfigFields(ctx, tmpDir, rawConnConfig, conf)
 	case HostMonitoringConnectionTypeName:
 		conf := &HostMonitoringConfig{}
 		err := rawConnConfig.Unmarshal(conf)
 		if err != nil {
 			logger.FromCtx(ctx).Error("failed to unmarshal config", zap.String("connection", c.Name))
+			return nil, err
+		}
+		configPaths, err = c.ProcessConfigFields(ctx, tmpDir, rawConnConfig, conf)
+		if err != nil {
+			return nil, err
 		}
-		configPaths, _ = c.ProcessConfigFields(ctx, tmpDir, rawConnConfig, conf)
+	default:
+		logger.FromCtx(ctx).Error("unknown connection type", zap.String("type", c.Type))
+		return nil, fmt.Errorf("unknown connection type %s", c.Type)
+	}
+	return configPaths, nil
+}
+
+type ConnectionTypeOption func(*ConnectionType)
+
+func MakeConnectionType(Name string, ConfigFields []CollectorConfigFragment, Type string, opts ...ConnectionTypeOption) *ConnectionType {
+	var c = &ConnectionType{Name: Name, ConfigFields: ConfigFields, Type: Type}
+	c.getConfig = func() *viper.Viper {
+		return viper.Sub(c.Name)
+	}
+	c.configFolderPath = GetConfigFolderPath()
+
+	// Apply provided options
+	for _, opt := range opts {
+		opt(c)
 	}
 
-	return configPaths
+	return c
+}
+
+func WithConfigFolderPath(configFolderPath string) ConnectionTypeOption {
+	return func(c *ConnectionType) {
+		c.configFolderPath = configFolderPath
+	}
+}
+
+func WithGetConfig(getConfig func() *viper.Viper) ConnectionTypeOption {
+	return func(c *ConnectionType) {
+		c.getConfig = getConfig
+	}
 }
 
 var AllConnectionTypes = []*ConnectionType{
-	&HostMonitoringConnectionType,
-	&SelfMonitoringConnectionType,
+	HostMonitoringConnectionType,
+	SelfMonitoringConnectionType,
 }