Merge pull request #88 from percona/PMM-2433-PMM-2434

PMM-2433, PMM-2434: Use new options, SlowLogRotation and RetainSlowLogs

Author: rnovikovP

glide.lock

@@ -13,15 +13,14 @@ import:
   - log/slow
   - query
 - package: github.com/percona/percona-toolkit
-  version: b53d67f6ead42c7c0e27b21c4f89b1cd3f349aee
   subpackages:
   - src/go/mongolib/explain
   - src/go/mongolib/fingerprinter
   - src/go/mongolib/proto
   - src/go/mongolib/stats
 - package: github.com/percona/pmgo
 - package: github.com/percona/pmm
-  version: f190773155b8927dee5c0400a6385bbb83a10f44
+  version: 88b7a3ea548f89aa63c3ec946c5a20db949db715
   subpackages:
   - proto
   - proto/config

glide.yaml

@@ -165,6 +165,11 @@ func (a *RealAnalyzer) TakeOverPerconaServerRotation() error {
 	a.logger.Debug("TakeOverPerconaServerRotation:call")
 	defer a.logger.Debug("TakeOverPerconaServerRotation:return")
 
+	// If slow log rotation is disabled, don't take over Percona Server slow log rotation.
+	if !boolValue(a.config.SlowLogRotation) {
+		return nil
+	}
+
 	// max_slowlog_size: https://www.percona.com/doc/percona-server/LATEST/flexibility/slowlog_rotation.html#max_slowlog_size
 	maxSlowLogSizeNullInt64, err := a.mysqlConn.GetGlobalVarInteger("max_slowlog_size")
 	if err != nil {
@@ -451,3 +456,12 @@ func (a *RealAnalyzer) runWorker(interval *iter.Interval) {
 		a.logger.Warn("Lost report:", err)
 	}
 }
+
+// boolValue returns the value of the bool pointer passed in or
+// false if the pointer is nil.
+func boolValue(v *bool) bool {
+	if v != nil {
+		return *v
+	}
+	return false
+}

qan/analyzer/mysql/analyzer.go

@@ -124,12 +124,14 @@ func (s *AnalyzerTestSuite) SetUpTest(t *C) {
 	s.worker = qan_worker.NewQanWorker()
 	// Config needs to be recreated on every test since it can be modified by the test analyzers
 	exampleQueries := true
+	slowLogRotation := true
 	s.config = pc.QAN{
-		UUID:           s.mysqlUUID,
-		CollectFrom:    "slowlog",
-		Interval:       60,
-		WorkerRunTime:  60,
-		MaxSlowLogSize: MAX_SLOW_LOG_SIZE,
+		UUID:            s.mysqlUUID,
+		CollectFrom:     "slowlog",
+		Interval:        60,
+		WorkerRunTime:   60,
+		MaxSlowLogSize:  MAX_SLOW_LOG_SIZE,
+		SlowLogRotation: &slowLogRotation,
 		Start: []string{
 			"-- start",
 		},

qan/analyzer/mysql/analyzer_test.go

@@ -27,14 +27,15 @@ import (
 )
 
 var (
-	DEFAULT_INTERVAL              uint  = 60         // 1 minute
-	DEFAULT_MAX_SLOW_LOG_SIZE     int64 = 1073741824 // 1G
-	DEFAULT_REMOVE_OLD_SLOW_LOGS        = true       // whether to remove old slow logs after rotation
-	DEFAULT_OLD_SLOW_LOGS_TO_KEEP       = 1          // how many slow logs to keep on filesystem
-	DEFAULT_EXAMPLE_QUERIES             = true
+	DefaultInterval          uint  = 60         // 1 minute
+	DefaultMaxSlowLogSize    int64 = 1073741824 // 1G
+	DefaultSlowLogRotation         = true       // whether to rotate slow logs
+	DefaultRemoveOldSlowLogs       = true       // whether to remove old slow logs after rotation
+	DefaultRetainSlowLogs          = 1          // how many slow logs to keep on filesystem
+	DefaultExampleQueries          = true
 	// internal
-	DEFAULT_WORKER_RUNTIME uint = 55
-	DEFAULT_REPORT_LIMIT   uint = 200
+	DefaultWorkerRuntime uint = 55
+	DefaultReportLimit   uint = 200
 )
 
 type MySQLVarType int
@@ -110,17 +111,32 @@ func ReadInfoFromShowGlobalStatus(conn mysql.Connector) (info map[string]interfa
 func ValidateConfig(setConfig pc.QAN) (pc.QAN, error) {
 	runConfig := pc.QAN{
 		UUID:           setConfig.UUID,
-		Interval:       DEFAULT_INTERVAL,
+		Interval:       DefaultInterval,
 		ExampleQueries: new(bool),
-		MaxSlowLogSize: DEFAULT_MAX_SLOW_LOG_SIZE,
-		WorkerRunTime:  DEFAULT_WORKER_RUNTIME,
-		ReportLimit:    DEFAULT_REPORT_LIMIT,
+		// "slowlog" specific options.
+		MaxSlowLogSize:  DefaultMaxSlowLogSize,
+		SlowLogRotation: new(bool),
+		RetainSlowLogs:  new(int),
+		// internal
+		WorkerRunTime: DefaultWorkerRuntime,
+		ReportLimit:   DefaultReportLimit,
 	}
 	// I know this is an ugly hack, but we need runConfig.ExampleQueries to be a pointer since
 	// the default value for a boolean is false, there is no way to tell if it was false in the
 	// config or if the value was missing.
 	// If it was missing (nil) we should take the default=true
-	*runConfig.ExampleQueries = DEFAULT_EXAMPLE_QUERIES
+	*runConfig.ExampleQueries = DefaultExampleQueries
+	if setConfig.ExampleQueries != nil {
+		runConfig.ExampleQueries = setConfig.ExampleQueries
+	}
+	*runConfig.SlowLogRotation = DefaultSlowLogRotation
+	if setConfig.SlowLogRotation != nil {
+		runConfig.SlowLogRotation = setConfig.SlowLogRotation
+	}
+	*runConfig.RetainSlowLogs = DefaultRetainSlowLogs
+	if setConfig.RetainSlowLogs != nil {
+		runConfig.RetainSlowLogs = setConfig.RetainSlowLogs
+	}
 
 	// Strings
 	if setConfig.CollectFrom != "slowlog" && setConfig.CollectFrom != "perfschema" {
@@ -133,11 +149,7 @@ func ValidateConfig(setConfig pc.QAN) (pc.QAN, error) {
 		return runConfig, fmt.Errorf("Interval must be > 0 and <= 3600 (1 hour)")
 	}
 	if setConfig.Interval > 0 {
-		runConfig.Interval = uint(setConfig.Interval)
-	}
-
-	if setConfig.ExampleQueries != nil {
-		runConfig.ExampleQueries = setConfig.ExampleQueries
+		runConfig.Interval = setConfig.Interval
 	}
 
 	runConfig.WorkerRunTime = uint(float64(runConfig.Interval) * 0.9) // 90% of interval

qan/analyzer/mysql/config/config.go

@@ -187,22 +187,15 @@ func (m *MySQLAnalyzer) Stop() error {
 
 func (m *MySQLAnalyzer) GetDefaults(uuid string) map[string]interface{} {
 	// Configuration
-	collectFrom := m.config.CollectFrom
-	interval := m.config.Interval
-	exampleQueries := m.config.ExampleQueries
-	// For old format of qan config, get Interval and ExampleQueries from running config.
-	if interval == 0 {
-		interval = m.analyzer.Config().Interval
-		exampleQueries = m.analyzer.Config().ExampleQueries
-	}
 	cfg := map[string]interface{}{
-		"CollectFrom":       collectFrom,
-		"Interval":          interval,
-		"MaxSlowLogSize":    config.DEFAULT_MAX_SLOW_LOG_SIZE,
-		"RemoveOldSlowLogs": config.DEFAULT_REMOVE_OLD_SLOW_LOGS,
-		"ExampleQueries":    exampleQueries,
-		"WorkerRunTime":     config.DEFAULT_WORKER_RUNTIME,
-		"ReportLimit":       config.DEFAULT_REPORT_LIMIT,
+		"CollectFrom":     m.config.CollectFrom,
+		"Interval":        m.config.Interval,
+		"MaxSlowLogSize":  config.DefaultMaxSlowLogSize,
+		"RetainSlowLogs":  m.config.RetainSlowLogs,
+		"SlowLogRotation": m.config.SlowLogRotation,
+		"ExampleQueries":  m.config.ExampleQueries,
+		"WorkerRunTime":   config.DefaultWorkerRuntime,
+		"ReportLimit":     config.DefaultReportLimit,
 	}
 
 	// Info from SHOW GLOBAL STATUS

qan/analyzer/mysql/mysql.go

@@ -285,12 +285,16 @@ func (s *WorkerTestSuite) TestRotateAndRemoveSlowLog(t *C) {
 
 	// See TestStartService() for description of these startup tasks.
 	exampleQueries := true
+	slowLogsRotation := true
+	slowLogsToKeep := 1
 	config := pc.QAN{
-		UUID:           s.mysqlInstance.UUID,
-		Interval:       300,
-		MaxSlowLogSize: 1000, // <-- HERE
-		ExampleQueries: &exampleQueries,
-		WorkerRunTime:  600,
+		UUID:            s.mysqlInstance.UUID,
+		Interval:        300,
+		MaxSlowLogSize:  1000, // <-- HERE
+		ExampleQueries:  &exampleQueries,
+		SlowLogRotation: &slowLogsRotation,
+		RetainSlowLogs:  &slowLogsToKeep,
+		WorkerRunTime:   600,
 		Start: []string{
 			"-- start",
 		},
@@ -384,12 +388,16 @@ func (s *WorkerTestSuite) TestRotateSlowLog(t *C) {
 
 	// See TestStartService() for description of these startup tasks.
 	exampleQueries := true
+	slowLogsRotation := true
+	slowLogsToKeep := 1
 	config := pc.QAN{
-		UUID:           s.mysqlInstance.UUID,
-		Interval:       300,
-		MaxSlowLogSize: 1000,
-		ExampleQueries: &exampleQueries,
-		WorkerRunTime:  600,
+		UUID:            s.mysqlInstance.UUID,
+		Interval:        300,
+		MaxSlowLogSize:  1000,
+		ExampleQueries:  &exampleQueries,
+		SlowLogRotation: &slowLogsRotation,
+		RetainSlowLogs:  &slowLogsToKeep,
+		WorkerRunTime:   600,
 		Start: []string{
 			"-- start",
 		},

qan/analyzer/mysql/worker/slowlog/slowlog_test.go

@@ -65,6 +65,7 @@ type Job struct {
 	StartOffset    int64
 	EndOffset      int64
 	ExampleQueries bool
+	RetainSlowLogs int
 }
 
 func (j *Job) String() string {
@@ -139,21 +140,30 @@ func (w *Worker) Setup(interval *iter.Interval) error {
 	w.logger.Debug("Setup:call")
 	defer w.logger.Debug("Setup:return")
 	w.logger.Debug("Setup:", interval)
-	if interval.EndOffset >= w.config.MaxSlowLogSize {
-		w.logger.Info(fmt.Sprintf("Rotating slow log: %s >= %s",
-			pct.Bytes(uint64(interval.EndOffset)),
-			pct.Bytes(uint64(w.config.MaxSlowLogSize))))
-		if err := w.rotateSlowLog(interval); err != nil {
-			w.logger.Error(err)
+
+	// Check if slow log rotation is enabled.
+	if boolValue(w.config.SlowLogRotation) {
+		// Check if max slow log size was reached.
+		if interval.EndOffset >= w.config.MaxSlowLogSize {
+			w.logger.Info(fmt.Sprintf("Rotating slow log: %s >= %s",
+				pct.Bytes(uint64(interval.EndOffset)),
+				pct.Bytes(uint64(w.config.MaxSlowLogSize))))
+			// Rotate slow log.
+			if err := w.rotateSlowLog(interval); err != nil {
+				w.logger.Error(err)
+			}
 		}
 	}
+
+	// Create new Job.
 	w.job = &Job{
 		Id:             fmt.Sprintf("%d", interval.Number),
 		SlowLogFile:    interval.Filename,
 		StartOffset:    interval.StartOffset,
 		EndOffset:      interval.EndOffset,
 		RunTime:        time.Duration(w.config.WorkerRunTime) * time.Second,
 		ExampleQueries: boolValue(w.config.ExampleQueries),
+		RetainSlowLogs: intValue(w.config.RetainSlowLogs),
 	}
 	w.logger.Debug("Setup:", w.job)
 
@@ -429,18 +439,18 @@ func (w *Worker) rotateSlowLog(interval *iter.Interval) error {
 	interval.EndOffset, _ = pct.FileSize(newSlowLogFile) // todo: handle err
 
 	// Purge old slow logs.
-	if !config.DEFAULT_REMOVE_OLD_SLOW_LOGS {
+	if !config.DefaultRemoveOldSlowLogs {
 		return nil
 	}
 	filesFound, err := filepath.Glob(fmt.Sprintf("%s-*", curSlowLog))
 	if err != nil {
 		return err
 	}
-	if len(filesFound) <= config.DEFAULT_OLD_SLOW_LOGS_TO_KEEP {
+	if len(filesFound) <= intValue(w.config.RetainSlowLogs) {
 		return nil
 	}
 	sort.Strings(filesFound)
-	for _, f := range filesFound[:len(filesFound)-config.DEFAULT_OLD_SLOW_LOGS_TO_KEEP] {
+	for _, f := range filesFound[:len(filesFound)-intValue(w.config.RetainSlowLogs)] {
 		w.status.Update(w.name, "Removing slow log "+f)
 		if err := os.Remove(f); err != nil {
 			w.logger.Warn(err)
@@ -460,3 +470,12 @@ func boolValue(v *bool) bool {
 	}
 	return false
 }
+
+// intValue returns the value of the int pointer passed in or
+// 0 if the pointer is nil.
+func intValue(v *int) int {
+	if v != nil {
+		return *v
+	}
+	return 0
+}

qan/analyzer/mysql/worker/slowlog/worker.go

@@ -564,7 +564,7 @@ func (s *ManagerTestSuite) TestStartTool(t *C) {
 	// For some reasons MaxSlowLogSize is explicitly marked to not be saved in config file
 	// type QAN struct {
 	//      ...
-	// 	MaxSlowLogSize int64  `json:"-"` // bytes, 0 = DEFAULT_MAX_SLOW_LOG_SIZE. Don't write it to the config
+	// 	MaxSlowLogSize int64  `json:"-"` // bytes, 0 = DefaultMaxSlowLogSize. Don't write it to the config
 	//      ...
 	// }
 	t.Check(gotConfig.MaxSlowLogSize, Equals, int64(0))