Add regexp mode to system logs search

core/api-server/README.md

@@ -248,7 +248,9 @@ INPUT
       "to": "2021-01-19T20:00:00Z",
       "entity" :"module",
       "entity_name": "traefik1",
-      "timezone": "Europe/Rome"
+      "timezone": "Europe/Rome",
+      "instance": "loki1",
+      "regexp": false
    }
 }
 ```
@@ -264,6 +266,8 @@ INPUT
     -   `entity`: must be `cluster` or `node` or `module` - `string`
     -   `entity_name`: could be empty (`cluster` case) or name of the entity - `string` (ex. hostname of the node or module id like `traefik1`)
     -   `timezone`: could be empty (default UTC) or a specific valid timezone (eg. Europe/Rome)
+    -   `instance`: could be empty (default loki instance) or the id of a specific loki instance - `string` (ex. `loki1`)
+    -   `regexp`: could be empty (default `false`) - `bool` (when `true` the `filter` is a RE2 regular expression instead of a substring)
 
 ```json
 OUTPUT
@@ -282,6 +286,7 @@ OUTPUT
 -   `payload`: contains the response logs
     -   `message`: contains the log message
     -   `pid`: is the pid of the process that actually reads log
+    -   `error`: present only when the query failed (invalid regexp, `logcli` error). `message` is empty in that case
 -   `timestamp`: timestamp of the action
 -   `type`: used to identify the websocket outputs
 
@@ -384,15 +389,17 @@ Use "api-server-logs [command] --help" for more information about a command.
       api-server-logs logs [flags]
 
     Flags:
-      -e, --entity string   get logs for a specific entity: cluster, node, module (default "cluster")
-      -f, --from string     get logs from a specific date. ISO8601 format
-      -h, --help            help for logs
-      -l, --lines string    get logs for a specific lines in dump mode (default "25")
-      -m, --mode string     get logs in a specific mode: tail or dump (default "tail")
-      -n, --name string     get logs for a specific entity name. used in node or module
-      -s, --search string   get logs for a specific search string
-      -t, --to string       get logs to a specific date. ISO8601 format
-      -z, --timezone string get logs in a specific timezone
+      -e, --entity string     get logs for a specific entity: cluster, node, module (default "cluster")
+      -f, --from string       get logs from a specific date. ISO8601 format
+      -h, --help              help for logs
+      -i, --instance string   search for logs in a specific instance. (Example: loki1, loki2, ...)
+      -l, --lines string      get logs for a specific lines in dump mode (default "25")
+      -m, --mode string       get logs in a specific mode: tail or dump (default "tail")
+      -n, --name string       get logs for a specific entity name. used in node or module
+      -r, --regexp            treat the search string as a regular expression instead of a substring
+      -s, --search string     get logs for a specific search string
+      -z, --timezone string   get logs in a specific timezone
+      -t, --to string         get logs to a specific date. ISO8601 format
     ```
 
 -   `version`: prints the command version

core/api-server/api-server-logs.go

@@ -25,10 +25,7 @@ package main
 import (
 	"github.com/NethServer/ns8-core/core/api-server/models"
 	"github.com/NethServer/ns8-core/core/api-server/socket"
-	"github.com/NethServer/ns8-core/core/api-server/utils"
-	"github.com/pkg/errors"
 
-	"encoding/json"
 	"fmt"
 	"os"
 	"sync"
@@ -48,6 +45,7 @@ var (
 	searchFlag     = ""
 	timezone       = ""
 	instance       = ""
+	regexpFlag     = false
 )
 
 var RootCmd = &cobra.Command{
@@ -86,6 +84,7 @@ func Execute() {
 	LogsCmd.Flags().StringVarP(&searchFlag, "search", "s", "", "get logs for a specific search string")
 	LogsCmd.Flags().StringVarP(&timezone, "timezone", "z", "", "get logs in a specific timezone")
 	LogsCmd.Flags().StringVarP(&instance, "instance", "i", "", "search for logs in a specific instance. (Example: loki1, loki2, ...)")
+	LogsCmd.Flags().BoolVarP(&regexpFlag, "regexp", "r", false, "treat the search string as a regular expression instead of a substring")
 
 	// check errors on cmd execution
 	if err := RootCmd.Execute(); err != nil {
@@ -99,29 +98,22 @@ func Logs() {
 	var wg sync.WaitGroup
 	wg.Add(1)
 
-	// define payload
-	payload := `
-  {
-   "action": "logs-start",
-   "payload": {
-      "id": "` + uuid.New().String() + `",
-      "mode": "` + modeFlag + `",
-      "lines": "` + linesFlag + `",
-      "filter": "` + searchFlag + `",
-      "from": "` + fromFlag + `",
-      "to": "` + toFlag + `",
-      "entity": "` + entityFlag + `",
-      "entity_name": "` + entityNameFlag + `",
-      "timezone": "` + timezone + `",
-      "instance": "` + instance + `"
-   }
-  }
-  `
-
 	// init command to execute
-	var action models.SocketAction
-	if errAction := json.Unmarshal([]byte(payload), &action); errAction != nil {
-		utils.LogError(errors.Wrap(errAction, "[LOG-CLI] error in Action json unmarshal"))
+	action := models.SocketAction{
+		Action: "logs-start",
+		Payload: models.LogsStartAction{
+			Id:         uuid.New().String(),
+			Mode:       modeFlag,
+			Lines:      linesFlag,
+			Filter:     searchFlag,
+			From:       fromFlag,
+			To:         toFlag,
+			Entity:     entityFlag,
+			EntityName: entityNameFlag,
+			TimeZone:   timezone,
+			Instance:   instance,
+			Regexp:     regexpFlag,
+		},
 	}
 
 	// execute command

core/api-server/models/socket.go

@@ -38,6 +38,7 @@ type LogsStartAction struct {
 	EntityName string `json:"entity_name" structs:"entity_name"`
 	TimeZone   string `json:"timezone" structs:"timezone"`
 	Instance   string `json:"instance" structs:"instance"`
+	Regexp     bool   `json:"regexp" structs:"regexp"`
 }
 
 type LogsStopAction struct {

core/api-server/socket/action.go

@@ -24,10 +24,12 @@ package socket
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
 	"os/exec"
+	"regexp"
 	"strconv"
 	"strings"
 	"sync"
@@ -100,9 +102,6 @@ func Action(socketAction models.SocketAction, s *melody.Session, wg *sync.WaitGr
 
 		// filter logs params
 		var mode = ""
-		var filter = ""
-		var streamSelector = ""
-		var logqlPipeline = ""
 		var from = ""
 		var to = ""
 		var timezone = "UTC"
@@ -143,29 +142,13 @@ func Action(socketAction models.SocketAction, s *melody.Session, wg *sync.WaitGr
 		}
 		args = append(args, mode)
 
-		// check filter
-		if len(logsAction.Filter) > 0 {
-			filter = ` |= "` + strings.ReplaceAll(logsAction.Filter, `"`, `\"`) + `"`
-		} else {
-			filter = ``
-		}
-
-		// switch entity
-		switch logsAction.Entity {
-		default:
-			streamSelector = `{node_id=~".+"}`
-
-		case "node":
-			streamSelector = `{node_id="` + logsAction.EntityName + `"}`
-
-		case "module":
-			streamSelector = `{module_id="` + logsAction.EntityName + `"}`
-		}
-
-		logqlPipeline = ` | json syslog_id="SYSLOG_IDENTIFIER", message="MESSAGE" | line_format "[{{.node_id}}:{{.module_id}}:{{.syslog_id}}] {{.message}}"`
-
 		// Compose and append the query strings to logcli arguments
-		args = append(args, streamSelector+logqlPipeline+filter)
+		query, errQuery := buildLogqlQuery(logsAction)
+		if errQuery != nil {
+			writeLogsQueryError(s, logsAction.Id, "invalid_regexp", errQuery.Error(), wg)
+			return
+		}
+		args = append(args, query)
 
 		// define command
 		cmd := exec.Command("/usr/local/bin/logcli", args...)
@@ -181,9 +164,13 @@ func Action(socketAction models.SocketAction, s *melody.Session, wg *sync.WaitGr
 			go func() {
 				pid := ""
 
+				var stderrBuf bytes.Buffer
+				cmd.Stderr = &stderrBuf
+
 				// create a pipe for the output of the script
 				stdout, errStdOut := cmd.StdoutPipe()
 				if errStdOut != nil {
+					writeLogsError(s, logsAction.Id, errStdOut.Error(), wg)
 					return
 				}
 
@@ -203,6 +190,7 @@ func Action(socketAction models.SocketAction, s *melody.Session, wg *sync.WaitGr
 				// start command
 				err = cmd.Start()
 				if err != nil {
+					writeLogsError(s, logsAction.Id, err.Error(), wg)
 					return
 				}
 
@@ -224,6 +212,18 @@ func Action(socketAction models.SocketAction, s *melody.Session, wg *sync.WaitGr
 				// use Wait to avoid defunct process when killed
 				err = cmd.Wait()
 				if err != nil {
+					// logs-stop kills the process: that exit is expected
+					if exitErr, isExitErr := err.(*exec.ExitError); isExitErr {
+						if status, isStatus := exitErr.Sys().(syscall.WaitStatus); isStatus && status.Signal() == syscall.SIGTERM {
+							return
+						}
+					}
+
+					message := strings.TrimSpace(stderrBuf.String())
+					if message == "" {
+						message = err.Error()
+					}
+					writeLogsError(s, logsAction.Id, message, wg)
 					return
 				}
 			}()
@@ -233,7 +233,12 @@ func Action(socketAction models.SocketAction, s *melody.Session, wg *sync.WaitGr
 			go func() {
 				out, err := cmd.Output()
 				if err != nil {
-					utils.LogError(errors.Wrap(err, "[SOCKET] error executing Cmd for dump"))
+					message := err.Error()
+					if exitErr, isExitErr := err.(*exec.ExitError); isExitErr && len(exitErr.Stderr) > 0 {
+						message = strings.TrimSpace(string(exitErr.Stderr))
+					}
+					writeLogsError(s, logsAction.Id, message, wg)
+					return
 				}
 
 				// reverse logs orders
@@ -291,6 +296,69 @@ func Action(socketAction models.SocketAction, s *melody.Session, wg *sync.WaitGr
 	}
 }
 
+// Reuses logs-start so the frontend one-shot listener is released.
+func writeLogsError(s *melody.Session, id string, message string, wg *sync.WaitGroup) {
+	// on the CLI this is what prints the message
+	utils.LogError(errors.New("[SOCKET] logs query failed: " + message))
+
+	if s != nil {
+		writeSocketResponse(s, "logs-start", gin.H{"id": id, "pid": "", "message": "", "error": message, "error_code": ""})
+		return
+	}
+	wg.Done()
+	os.Exit(1)
+}
+
+// Same, for a query the user can fix: the code picks the frontend wording, and
+// a typo is not a server fault, so it is reported without being logged.
+func writeLogsQueryError(s *melody.Session, id string, code string, message string, wg *sync.WaitGroup) {
+	if s != nil {
+		writeSocketResponse(s, "logs-start", gin.H{"id": id, "pid": "", "message": "", "error": message, "error_code": code})
+		return
+	}
+	fmt.Fprintln(os.Stderr, message)
+	wg.Done()
+	os.Exit(1)
+}
+
+// LogQL strings use Go escape rules: a raw backslash must be doubled.
+func escapeLogqlString(s string) string {
+	s = strings.ReplaceAll(s, `\`, `\\`)
+	return strings.ReplaceAll(s, `"`, `\"`)
+}
+
+func buildLogqlQuery(logsAction models.LogsStartAction) (string, error) {
+	var streamSelector string
+
+	switch logsAction.Entity {
+	default:
+		streamSelector = `{node_id=~".+"}`
+
+	case "node":
+		streamSelector = `{node_id="` + escapeLogqlString(logsAction.EntityName) + `"}`
+
+	case "module":
+		streamSelector = `{module_id="` + escapeLogqlString(logsAction.EntityName) + `"}`
+	}
+
+	logqlPipeline := ` | json syslog_id="SYSLOG_IDENTIFIER", message="MESSAGE" | line_format "[{{.node_id}}:{{.module_id}}:{{.syslog_id}}] {{.message}}"`
+
+	filter := ""
+	if len(logsAction.Filter) > 0 {
+		operator := `|=`
+		if logsAction.Regexp {
+			// Loki runs RE2, so Go rejects exactly what Loki would
+			if _, err := regexp.Compile(logsAction.Filter); err != nil {
+				return "", err
+			}
+			operator = `|~`
+		}
+		filter = ` ` + operator + ` "` + escapeLogqlString(logsAction.Filter) + `"`
+	}
+
+	return streamSelector + logqlPipeline + filter, nil
+}
+
 func reverse(ss []string) []string {
 	last := len(ss) - 1
 	for i := 0; i < len(ss)/2; i++ {

core/api-server/socket/socket.go

@@ -44,6 +44,9 @@ func Instance() *melody.Melody {
 		muClock = new(utils.MuClock)
 		muClock.Sync()
 		socketConnection = melody.New()
+		// melody defaults to 512 bytes and closes the connection past it: a
+		// logs-start payload is 280 bytes with an empty search query
+		socketConnection.Config.MaxMessageSize = 65536
 		socketConnection.HandleDisconnect(onDisconnect)
 		socketConnection.HandleMessage(onMessage)
 		socketConnection.HandlePong(onPong)

core/ui/public/i18n/en/translation.json

@@ -1178,15 +1178,27 @@
         "title": "System logs",
         "start_date": "Start date",
         "end_date": "End date",
-        "start_time_label": "Start time (24-hour)",
-        "end_time_label": "End time (24-hour)",
+        "start_time_label": "Start time",
+        "end_time_label": "End time",
+        "time_format_helper": "24-hour",
         "start": "Start",
         "end": "End",
         "context": "Context",
         "context_cluster": "Cluster",
         "context_node": "Node",
         "context_module": "Application",
         "search_query": "Search query",
+        "regexp": "Regular expression",
+        "regexp_helper": "RE2 syntax is accepted. Hint: '(?i)' ignores case, '|' matches any of the words",
+        "substring_helper": "Exact and case-sensitive substring match",
+        "search_failed": "Log search failed",
+        "websocket_disconnected": "The connection to the server was lost while the query was running. Run the search again.",
+        "invalid_regexp": "Invalid regular expression",
+        "invalid_regexp_description": "The search pattern is not valid RE2 syntax: {detail}",
+        "showing_lines": "Showing {n} lines from {from} to {to}",
+        "showing_lines_of": "Showing {n} of {max} lines from {from} to {to}",
+        "showing_lines_no_interval": "Showing {n} lines",
+        "showing_lines_of_no_interval": "Showing {n} of {max} lines",
         "max_lines": "Max lines",
         "wrap_text": "Wrap text",
         "search": "Search",

core/ui/src/components/system-logs/LogOutput.vue

@@ -178,9 +178,10 @@ export default {
   background-image: none;
 }
 
-// show scrollbar
+// show scrollbar, and grow so it lands on the edge, not on the longest line
 .system-logs .logs-output.bx--snippet--multi .bx--snippet-container {
   overflow-y: auto !important;
+  flex: 1 1 auto;
 }
 
 .logs-output {