Support Firecracker's new logging and metrics

Previously Firecracker had a single operation to set logging and
metrics, and the fields specifically mentioned "FIFO".

Now the operation is broken into two and it doesn't mention "FIFO"
anymore.

This change keeps MetricsFifo and LogFifo to be backward-compatible.

Signed-off-by: Kazuyoshi Kato <katokazu@amazon.com>

fix

Author: Kazuyoshi Kato

firecracker.go

@@ -94,6 +94,25 @@ func (f *Client) PutLogger(ctx context.Context, logger *models.Logger, opts ...P
 	return f.client.Operations.PutLogger(loggerParams)
 }
 
+// PutMetricsOpt is a functional option to be used for the PutMetrics API in
+// setting any additional optional fields.
+type PutMetricsOpt func(*ops.PutMetricsParams)
+
+// PutMetrics is a wrapper for the swagger generated client to make calling of
+// the API easier.
+func (f *Client) PutMetrics(ctx context.Context, metrics *models.Metrics, opts ...PutMetricsOpt) (*ops.PutMetricsNoContent, error) {
+	timeout, cancel := context.WithTimeout(ctx, time.Duration(f.firecrackerRequestTimeout)*time.Millisecond)
+	defer cancel()
+
+	params := ops.NewPutMetricsParamsWithContext(timeout)
+	params.SetBody(metrics)
+	for _, opt := range opts {
+		opt(params)
+	}
+
+	return f.client.Operations.PutMetrics(params)
+}
+
 // PutMachineConfigurationOpt is a functional option to be used for the
 // PutMachineConfiguration API in setting any additional optional fields.
 type PutMachineConfigurationOpt func(*ops.PutMachineConfigurationParams)

handlers.go

@@ -119,40 +119,44 @@ var StartVMMHandler = Handler{
 	},
 }
 
-// CreateLogFilesHandler is a named handler that will create the fifo log files
-var CreateLogFilesHandler = Handler{
-	Name: CreateLogFilesHandlerName,
-	Fn: func(ctx context.Context, m *Machine) error {
-		logFifoPath := m.Cfg.LogFifo
-		metricsFifoPath := m.Cfg.MetricsFifo
-
-		if len(logFifoPath) == 0 || len(metricsFifoPath) == 0 {
-			// logging is disabled
-			return nil
-		}
-
-		if err := createFifos(logFifoPath, metricsFifoPath); err != nil {
-			m.logger.Errorf("Unable to set up logging: %s", err)
+func createFifoOrFile(ctx context.Context, m *Machine, fifo, path string) error {
+	if len(fifo) > 0 {
+		if err := createFifo(fifo); err != nil {
 			return err
 		}
 
 		m.cleanupFuncs = append(m.cleanupFuncs,
 			func() error {
-				if err := os.Remove(logFifoPath); !os.IsNotExist(err) {
-					return err
-				}
-				return nil
-			},
-			func() error {
-				if err := os.Remove(metricsFifoPath); !os.IsNotExist(err) {
+				if err := os.Remove(fifo); !os.IsNotExist(err) {
 					return err
 				}
 				return nil
 			},
 		)
+	} else if len(path) > 0 {
+		file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0600)
+		if err != nil {
+			return err
+		}
+		file.Close()
+	}
+	return nil
+}
+
+// CreateLogFilesHandler is a named handler that will create the fifo log files
+var CreateLogFilesHandler = Handler{
+	Name: CreateLogFilesHandlerName,
+	Fn: func(ctx context.Context, m *Machine) error {
+		if err := createFifoOrFile(ctx, m, m.Cfg.MetricsFifo, m.Cfg.MetricsPath); err != nil {
+			return err
+		}
+
+		if err := createFifoOrFile(ctx, m, m.Cfg.LogFifo, m.Cfg.LogPath); err != nil {
+			return err
+		}
 
 		if m.Cfg.FifoLogWriter != nil {
-			if err := m.captureFifoToFile(ctx, m.logger, logFifoPath, m.Cfg.FifoLogWriter); err != nil {
+			if err := m.captureFifoToFile(ctx, m.logger, m.Cfg.LogFifo, m.Cfg.FifoLogWriter); err != nil {
 				m.logger.Warnf("captureFifoToFile() returned %s. Continuing anyway.", err)
 			}
 		}
@@ -171,6 +175,9 @@ var BootstrapLoggingHandler = Handler{
 		if err := m.setupLogging(ctx); err != nil {
 			return err
 		}
+		if err := m.setupMetrics(ctx); err != nil {
+			return err
+		}
 		m.logger.Debugf("setup logging: success")
 		return nil
 	},

machine.go

@@ -78,6 +78,9 @@ type Config struct {
 	// should be created.
 	SocketPath string
 
+	// LogPath defines the file path where the Firecracker log is located.
+	LogPath string
+
 	// LogFifo defines the file path where the Firecracker log named-pipe should
 	// be located.
 	LogFifo string
@@ -86,6 +89,10 @@ type Config struct {
 	// "Error", "Warning", "Info", and "Debug", and are case-sensitive.
 	LogLevel string
 
+	// MetricsPath defines the file path where the Firecracker metrics
+	// is located.
+	MetricsPath string
+
 	// MetricsFifo defines the file path where the Firecracker metrics
 	// named-pipe should be located.
 	MetricsFifo string
@@ -585,29 +592,29 @@ func (m *Machine) stopVMM() error {
 	return nil
 }
 
-// createFifos sets up the firecracker logging and metrics FIFOs
-func createFifos(logFifo, metricsFifo string) error {
-	log.Debugf("Creating FIFO %s", logFifo)
-	if err := syscall.Mkfifo(logFifo, 0700); err != nil {
+// createFifo sets up a FIFOs
+func createFifo(path string) error {
+	log.Debugf("Creating FIFO %s", path)
+	if err := syscall.Mkfifo(path, 0700); err != nil {
 		return fmt.Errorf("Failed to create log fifo: %v", err)
 	}
-
-	log.Debugf("Creating metric FIFO %s", metricsFifo)
-	if err := syscall.Mkfifo(metricsFifo, 0700); err != nil {
-		return fmt.Errorf("Failed to create metric fifo: %v", err)
-	}
 	return nil
 }
 
 func (m *Machine) setupLogging(ctx context.Context) error {
-	if len(m.Cfg.LogFifo) == 0 || len(m.Cfg.MetricsFifo) == 0 {
+	path := m.Cfg.LogPath
+	if len(m.Cfg.LogFifo) > 0 {
+		path = m.Cfg.LogFifo
+	}
+
+	if len(path) == 0 {
 		// No logging configured
-		m.logger.Printf("VMM logging and metrics disabled.")
+		m.logger.Printf("VMM logging disabled.")
 		return nil
 	}
 
 	l := models.Logger{
-		LogPath:       String(m.Cfg.LogFifo),
+		LogPath:       String(path),
 		Level:         String(m.Cfg.LogLevel),
 		ShowLevel:     Bool(true),
 		ShowLogOrigin: Bool(false),
@@ -618,10 +625,31 @@ func (m *Machine) setupLogging(ctx context.Context) error {
 		return err
 	}
 
-	m.logger.Debugf("Configured VMM logging to %s, metrics to %s",
-		m.Cfg.LogFifo,
-		m.Cfg.MetricsFifo,
-	)
+	m.logger.Debugf("Configured VMM logging to %s", path)
+
+	return nil
+}
+
+func (m *Machine) setupMetrics(ctx context.Context) error {
+	path := m.Cfg.MetricsPath
+	if len(m.Cfg.MetricsFifo) > 0 {
+		path = m.Cfg.MetricsFifo
+	}
+
+	if len(path) == 0 {
+		// No logging configured
+		m.logger.Printf("VMM metrics disabled.")
+		return nil
+	}
+
+	_, err := m.client.PutMetrics(ctx, &models.Metrics{
+		MetricsPath: String(path),
+	})
+	if err != nil {
+		return err
+	}
+
+	m.logger.Debugf("Configured VMM metrics to %s", path)
 
 	return nil
 }

machine_test.go

@@ -419,6 +419,61 @@ func TestStartVMM(t *testing.T) {
 	assert.False(t, closed)
 }
 
+func TestLogAndMetrics(t *testing.T) {
+	dir, err := ioutil.TempDir("", t.Name())
+	require.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	socketPath := filepath.Join(dir, "fc.sock")
+
+	cfg := Config{
+		SocketPath:        socketPath,
+		DisableValidation: true,
+		KernelImagePath:   getVmlinuxPath(t),
+		MachineCfg: models.MachineConfiguration{
+			VcpuCount:   Int64(1),
+			MemSizeMib:  Int64(64),
+			CPUTemplate: models.CPUTemplate(models.CPUTemplateT2),
+			HtEnabled:   Bool(false),
+		},
+		MetricsPath: filepath.Join(dir, "fc-metrics.out"),
+		LogPath:     filepath.Join(dir, "fc.log"),
+		LogLevel:    "Debug",
+	}
+	ctx := context.Background()
+	cmd := VMCommandBuilder{}.
+		WithSocketPath(cfg.SocketPath).
+		WithBin(getFirecrackerBinaryPath()).
+		Build(ctx)
+	m, err := NewMachine(ctx, cfg, WithProcessRunner(cmd), WithLogger(fctesting.NewLogEntry(t)))
+	require.NoError(t, err)
+
+	timeout, cancel := context.WithTimeout(ctx, 250*time.Millisecond)
+	defer cancel()
+
+	err = m.Start(timeout)
+	require.NoError(t, err)
+	defer m.StopVMM()
+
+	select {
+	case <-timeout.Done():
+		if timeout.Err() == context.DeadlineExceeded {
+			t.Log("firecracker ran for 250ms")
+			t.Run("TestStopVMM", func(t *testing.T) { testStopVMM(ctx, t, m) })
+		} else {
+			t.Errorf("startVMM returned %s", m.Wait(ctx))
+		}
+	}
+
+	metrics, err := os.Stat(cfg.MetricsPath)
+	require.NoError(t, err)
+	assert.NotEqual(t, 0, metrics.Size())
+
+	log, err := os.Stat(cfg.LogPath)
+	require.NoError(t, err)
+	assert.NotEqual(t, 0, log.Size())
+}
+
 func TestStartVMMOnce(t *testing.T) {
 	socketPath := filepath.Join("testdata", "TestStartVMMOnce.sock")
 	defer os.Remove(socketPath)