fix: Align template variables with Docker nomenclature

The .ContainerName was in fact the service name when using compose. It's
now the actual container name and the service name is available as
.ServiceName. For convenience .ServiceName is set to the container name
when using plain docker.

When support for Swarm is added the naming becomes inconsistent as the
name for the same concept changes between Swarm and non-Swarm. A compose
project is the equivalent of a Swarm namespace/stack. So the
.ComposeProject is changed to .Namespace as it's a quite neutral name
for both setups. The .ComposeColor is changed accordingly.

Similarly, in compose the container instance is called container number
whereas in Swarm it's called a slot. The new variable to be used for
both is .ContainerNumber.

Author: hogklint

README.md

@@ -39,16 +39,16 @@ The `container query` is a regular expression of the container name; you could p
  `--color`                   | `auto`                          | Force set color output. 'auto':  colorize if tty attached, 'always': always colorize, 'never': never colorize.
  `--completion`              |                                 | Output tailfin command-line completion code for the specified shell. Can be 'bash', 'zsh' or 'fish'.
  `--compose`                 | `[]`                            | Compose project name to match (regular expression)
- `--compose-colors`          |                                 | Specifies the colors used to highlight container names. Provide colors as a comma-separated list using SGR (Select Graphic Rendition) sequences, e.g., "91,92,93,94,95,96".
  `--config`                  | `~/.config/tailfin/config.yaml` | Path to the tailfin config file
- `--container-colors`        |                                 | Specifies the colors used to highlight compose project names. Use the same format as --container-colors. Defaults to the values of --container-colors if omitted, and must match its length.
+ `--container-colors`        |                                 | Specifies the colors used to highlight container names. Provide colors as a comma-separated list using SGR (Select Graphic Rendition) sequences, e.g., "91,92,93,94,95,96".
  `--exclude`, `-e`           | `[]`                            | Log lines to exclude. (regular expression)
  `--exclude-container`, `-E` | `[]`                            | Container name to exclude. (regular expression)
  `--highlight`, `-H`         | `[]`                            | Log lines to highlight. (regular expression)
  `--image`, `-m`             | `[]`                            | Images to match (regular expression)
  `--include`, `-i`           | `[]`                            | Log lines to include. (regular expression)
  `--label`, `-l`             | `[]`                            | Label query to filter on. One key or `key=value` per flag instance.
  `--max-log-requests`        | `-1`                            | Maximum number of concurrent logs to request. Defaults to 50, but 5 when specifying --no-follow
+ `--namespace-colors`        |                                 | Specifies the colors used to highlight namespace (compose project). Use the same format as --container-colors. Defaults to the values of --container-colors if omitted, and must match its length.
  `--no-follow`               | `false`                         | Exit when all logs have been shown.
  `--only-log-lines`          | `false`                         | Print only log lines
  `--output`, `-o`            | `default`                       | Specify predefined template. Currently support: [default, raw, json, extjson, ppextjson]
@@ -95,19 +95,22 @@ It accepts a custom template through the `--template` flag, which will be
 compiled to a Go template and then used for every log message. This Go template
 will receive the following struct:
 
-| property        | type   | description                                    |
-|-----------------|--------|------------------------------------------------|
-| `Message`       | string | The log message itself                         |
-| `ComposeProject`| string | The name of the docker compose project, if any |
-| `ContainerName` | string | The name of the container                      |
+| property         | type   | Docker         | Compose                   |
+|------------------|--------|----------------|---------------------------|
+| `Message`        | string | Log message    | Log message               |
+| `ContainerName`  | string | Container name | Container name            |
+| `ServiceName`    | string | Container name | Service name              |
+| `Namespace`      | string | -              | Compose project name      |
+| `ContainerNumber`| string | -              | Container number          |
+<!-- TODO:Labels --->
 
 The following functions are available within the template (besides the [builtin
 functions](https://golang.org/pkg/text/template/#hdr-Functions)):
 
 | func            | arguments             | description                                                                       |
 |-----------------|-----------------------|-----------------------------------------------------------------------------------|
 | `json`          | `object`              | Marshal the object and output it as a json text                                   |
-| `color`         | `color.Color, string` | Wrap the text in color (.ContainerColor and .ComposeColor provided)               |
+| `color`         | `color.Color, string` | Wrap the text in color (.ContainerColor and .NamespaceColor provided)             |
 | `parseJSON`     | `string`              | Parse string as JSON                                                              |
 | `tryParseJSON`  | `string`              | Attempt to parse string as JSON, return nil on failure                            |
 | `extractJSONParts`    | `string, ...string` | Parse string as JSON and concatenate the given keys.                          |
@@ -145,21 +148,21 @@ You can configure highlight colors for compose projects and containers in [the c
 
 ```yaml
 # Green, Yellow, Blue, Magenta, Cyan, White
-compose-colors: "32,33,34,35,36,37"
+namespace-colors: "32,33,34,35,36,37"
 
 # Colors with underline (4)
-# If empty, the compose colors will be used as container colors
+# If empty, the namespace will be used as container colors
 container-colors: "32;4,33;4,34;4,35;4,36;4,37;4"
 ```
 
 This format enables the use of various attributes, such as underline, background colors, 8-bit colors, and 24-bit colors, if your terminal supports them.
 
-The equivalent flags `--compose-colors` and `--container-colors` are also available. The following command applies [24-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit) using the `--compose-colors` flag.
+The equivalent flags `--namespace-colors` and `--container-colors` are also available. The following command applies [24-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit) using the `--namespace-colors` flag.
 
 ```bash
 # Monokai theme
-composeColors="38;2;255;97;136,38;2;169;220;118,38;2;255;216;102,38;2;120;220;232,38;2;171;157;242"
-tailfin --compose-colors "$composeColors" app
+namespaceColor="38;2;255;97;136,38;2;169;220;118,38;2;255;216;102,38;2;120;220;232,38;2;171;157;242"
+tailfin --namespace-colors "$namespaceColor" app
 ```
 
 ## Examples:
@@ -217,25 +220,25 @@ tailfin backend -o raw
 Output using a custom template:
 
 ```
-tailfin --template '{{printf "%s (%s/%s)\n" .Message .ComposeProject .ContainerName}}' backend
+tailfin --template '{{printf "%s (%s/%s)\n" .Message .Namespace .ContainerName}}' backend
 ```
 
 Output using a custom template with tailfin-provided colors:
 
 ```
-tailfin --template '{{.Message}} ({{color .ComposeColor .ComposeProject}}/{{color .ContainerColor .ContainerName}}){{"\n"}}' backend
+tailfin --template '{{.Message}} ({{color .NamespaceColor .Namespace}}/{{color .ContainerColor .ContainerName}}){{"\n"}}' backend
 ```
 
 Output using a custom template with `parseJSON`:
 
 ```
-tailfin --template='{{.ComposeProject}}/{{.ContainerName}} {{with $d := .Message | parseJSON}}[{{$d.level}}] {{$d.message}}{{end}}{{"\n"}}' backend
+tailfin --template='{{.Namespace}}/{{.ContainerName}} {{with $d := .Message | parseJSON}}[{{$d.level}}] {{$d.message}}{{end}}{{"\n"}}' backend
 ```
 
 Output using a custom template that tries to parse JSON or fallbacks to raw format:
 
 ```
-tailfin --template='{{.ComposeProject}}/{{.ContainerName}} {{ with $msg := .Message | tryParseJSON }}[{{ colorGreen (toRFC3339Nano $msg.ts) }}] {{ levelColor $msg.level }} ({{ colorCyan $msg.caller }}) {{ $msg.msg }}{{ else }} {{ .Message }} {{ end }}{{"\n"}}' backend
+tailfin --template='{{.Namespace}}/{{.ContainerName}} {{ with $msg := .Message | tryParseJSON }}[{{ colorGreen (toRFC3339Nano $msg.ts) }}] {{ levelColor $msg.level }} ({{ colorCyan $msg.caller }}) {{ $msg.msg }}{{ else }} {{ .Message }} {{ end }}{{"\n"}}' backend
 ```
 
 Load custom template from file:

cmd/tailfincmd/cmd.go

@@ -72,10 +72,9 @@ type options struct {
 	configFilePath   string
 	stdin            bool
 	containerColors  []string
-	composeColors    []string
+	namespaceColor   []string
 	//containerStates     []string
 	//selector            string
-	//compose            []string
 
 	dockerClient *dockerclient.Client
 }
@@ -263,8 +262,8 @@ func (o *options) setVerbosity() error {
 }
 
 func (o *options) setColorList() error {
-	if len(o.containerColors) > 0 || len(o.composeColors) > 0 {
-		return stern.SetColorList(o.composeColors, o.containerColors)
+	if len(o.containerColors) > 0 || len(o.namespaceColor) > 0 {
+		return stern.SetColorList(o.namespaceColor, o.containerColors)
 	}
 	return nil
 }
@@ -356,10 +355,9 @@ func (o *options) AddFlags(fs *pflag.FlagSet) {
 	fs.IntVar(&o.verbosity, "verbosity", o.verbosity, "Number of the log level verbosity")
 	fs.BoolVarP(&o.version, "version", "v", o.version, "Print the version and exit.")
 	fs.BoolVar(&o.stdin, "stdin", o.stdin, "Parse logs from stdin. All Docker related flags are ignored when it is set.")
-	fs.StringSliceVar(&o.containerColors, "compose-colors", o.containerColors, "Specifies the colors used to highlight container names. Provide colors as a comma-separated list using SGR (Select Graphic Rendition) sequences, e.g., \"91,92,93,94,95,96\".")
-	fs.StringSliceVar(&o.composeColors, "container-colors", o.composeColors, "Specifies the colors used to highlight compose project names. Use the same format as --container-colors. Defaults to the values of --container-colors if omitted, and must match its length.")
+	fs.StringSliceVar(&o.containerColors, "container-colors", o.containerColors, "Specifies the colors used to highlight container names. Provide colors as a comma-separated list using SGR (Select Graphic Rendition) sequences, e.g., \"91,92,93,94,95,96\".")
+	fs.StringSliceVar(&o.namespaceColor, "namespace-colors", o.namespaceColor, "Specifies the colors used to highlight namespace (compose project). Use the same format as --container-colors. Defaults to the values of --container-colors if omitted, and must match its length.")
 	// TODO: --context for docker context? Seems to be a `docker` thing, not a dockerd thing.
-	// TODO: --ignore-compose to make it unaware of compose (e.g. use full container name)
 	// TODO  --prompt??
 
 	fs.Lookup("timestamps").NoOptDefVal = "default"
@@ -377,15 +375,15 @@ func (o *options) generateTemplate() (*template.Template, error) {
 	if t == "" {
 		switch o.output {
 		case "default":
-			t = "{{if .ComposeProject}}{{color .ComposeColor .ComposeProject}} {{end}}{{color .ContainerColor .ContainerName}} {{.Message}}"
+			t = "{{if .Namespace}}{{color .NamespaceColor .Namespace}} {{end}}{{color .ContainerColor .ServiceName}} {{.Message}}"
 		case "raw":
 			t = "{{.Message}}"
 		case "json":
 			t = "{{json .}}"
 		case "extjson":
-			t = "{\"compose\": \"{{if .ComposeProject}}{{color .ComposeColor .ComposeProject}}{{end}}\", \"container\": \"{{color .ContainerColor .ContainerName}}\", \"message\": {{extjson .Message}}}"
+			t = "{\"namespace\": \"{{if .Namespace}}{{color .NamespaceColor .Namespace}}{{end}}\", \"service\": \"{{color .ContainerColor .ServiceName}}\", \"message\": {{extjson .Message}}}"
 		case "ppextjson":
-			t = "{\n  \"compose\": \"{{if .ComposeProject}}{{color .ComposeColor .ComposeProject}}{{end}}\",\n  \"container\": \"{{color .ContainerColor .ContainerName}}\",\n  \"message\": {{extjson .Message}}\n}"
+			t = "{\n  \"namespace\": \"{{if .Namespace}}{{color .NamespaceColor .Namespace}}{{end}}\",\n  \"service\": \"{{color .ContainerColor .ServiceName}}\",\n  \"message\": {{extjson .Message}}\n}"
 		default:
 			return nil, errors.New("output should be one of 'default', 'raw', 'json', 'extjson', and 'ppextjson'")
 		}

cmd/tailfincmd/cmd_test.go

@@ -208,7 +208,7 @@ func TestOptionsGenerateTemplate(t *testing.T) {
 				return o
 			}(),
 			"default message",
-			"compose1 container1 default message\n",
+			"compose1 service1 default message\n",
 			false,
 			true,
 		},
@@ -234,7 +234,7 @@ func TestOptionsGenerateTemplate(t *testing.T) {
 				return o
 			}(),
 			"json message",
-			`{"message":"json message","container":"container1","compose":"compose1"}
+			`{"message":"json message","container":"container1","service":"service1","namespace":"compose1","number":"0"}
 `,
 			false,
 			true,
@@ -248,7 +248,7 @@ func TestOptionsGenerateTemplate(t *testing.T) {
 				return o
 			}(),
 			`{"msg":"extjson message"}`,
-			`{"compose": "compose1", "container": "container1", "message": {"msg":"extjson message"}}
+			`{"namespace": "compose1", "service": "service1", "message": {"msg":"extjson message"}}
 `,
 			false,
 			true,
@@ -263,8 +263,8 @@ func TestOptionsGenerateTemplate(t *testing.T) {
 			}(),
 			`{"msg":"ppextjson message"}`,
 			`{
-  "compose": "compose1",
-  "container": "container1",
+  "namespace": "compose1",
+  "service": "service1",
   "message": {"msg":"ppextjson message"}
 }
 `,
@@ -288,12 +288,12 @@ func TestOptionsGenerateTemplate(t *testing.T) {
 			"template",
 			func() *options {
 				o := NewOptions(streams)
-				o.template = "Message={{.Message}} ComposeProject={{.ComposeProject}} ContainerName={{.ContainerName}}"
+				o.template = "Message={{.Message}} Namespace={{.Namespace}} ContainerName={{.ContainerName}}"
 
 				return o
 			}(),
 			"template message", // no new line
-			"Message=template message ComposeProject=compose1 ContainerName=container1",
+			"Message=template message Namespace=compose1 ContainerName=container1",
 			false,
 			true,
 		},
@@ -380,11 +380,14 @@ func TestOptionsGenerateTemplate(t *testing.T) {
 			log := stern.Log{
 				Message:        tt.message,
 				ContainerName:  "container1",
+				ServiceName:    "container1",
 				ContainerColor: color.New(color.FgBlue),
 			}
 			if tt.withCompose {
-				log.ComposeProject = "compose1"
-				log.ComposeColor = color.New(color.FgBlue)
+				log.Namespace = "compose1"
+				log.ServiceName = "service1"
+				log.ContainerNumber = "0"
+				log.NamespaceColor = color.New(color.FgBlue)
 			}
 			tmpl, err := tt.o.generateTemplate()
 

cmd/tailfincmd/test.tpl

@@ -1 +1 @@
-{{color .ComposeColor .ComposeProject}} {{color .ContainerColor .ContainerName}} {{ with $msg := .Message | tryParseJSON }}[{{ colorGreen (toRFC3339Nano (toUTC $msg.ts)) }}] {{ levelColor $msg.level }} {{ $msg.msg }}{{ else }}{{ .Message }}{{ end }}
+{{color .NamespaceColor .Namespace}} {{color .ContainerColor .ContainerName}} {{ with $msg := .Message | tryParseJSON }}[{{ colorGreen (toRFC3339Nano (toUTC $msg.ts)) }}] {{ levelColor $msg.level }} {{ $msg.msg }}{{ else }}{{ .Message }}{{ end }}

stern/color.go

@@ -24,41 +24,41 @@ func colorIndex(name string) uint32 {
 	return hash.Sum32() % uint32(len(colorList))
 }
 
-func SetColorList(composeColors, containerColors []string) error {
-	colors, err := parseColors(composeColors, containerColors)
+func SetColorList(namespaceColor, containerColors []string) error {
+	colors, err := parseColors(namespaceColor, containerColors)
 	if err != nil {
 		return err
 	}
 	colorList = colors
 	return nil
 }
 
-func parseColors(composeColors, containerColors []string) ([][2]*color.Color, error) {
-	if len(composeColors) == 0 {
-		return nil, errors.New("compose-colors must not be empty")
+func parseColors(namespaceColor, containerColors []string) ([][2]*color.Color, error) {
+	if len(namespaceColor) == 0 {
+		return nil, errors.New("namespace-colors must not be empty")
 	}
 	if len(containerColors) == 0 {
-		// if containerColors is empty, use composeColors as containerColors
-		return createColorPairs(composeColors, composeColors)
+		// if containerColors is empty, use namespaceColor as containerColors
+		return createColorPairs(namespaceColor, namespaceColor)
 	}
-	if len(containerColors) != len(composeColors) {
-		return nil, errors.New("compose-colors and container-colors must have the same length")
+	if len(containerColors) != len(namespaceColor) {
+		return nil, errors.New("namespace-colors and container-colors must have the same length")
 	}
-	return createColorPairs(composeColors, containerColors)
+	return createColorPairs(namespaceColor, containerColors)
 }
 
-func createColorPairs(composeColors, containerColors []string) ([][2]*color.Color, error) {
-	colorList := make([][2]*color.Color, 0, len(composeColors))
-	for i := 0; i < len(composeColors); i++ {
-		composeColor, err := sgrSequenceToColor(composeColors[i])
+func createColorPairs(namespaceColor, containerColors []string) ([][2]*color.Color, error) {
+	colorList := make([][2]*color.Color, 0, len(namespaceColor))
+	for i := 0; i < len(namespaceColor); i++ {
+		namespaceColor, err := sgrSequenceToColor(namespaceColor[i])
 		if err != nil {
 			return nil, err
 		}
 		containerColor, err := sgrSequenceToColor(containerColors[i])
 		if err != nil {
 			return nil, err
 		}
-		colorList = append(colorList, [2]*color.Color{composeColor, containerColor})
+		colorList = append(colorList, [2]*color.Color{namespaceColor, containerColor})
 	}
 	return colorList, nil
 }

stern/color_test.go

@@ -9,14 +9,14 @@ import (
 func TestParseColors(t *testing.T) {
 	tests := []struct {
 		desc            string
-		composeColors   []string
+		namespaceColors []string
 		containerColors []string
 		want            [][2]*color.Color
 		wantError       bool
 	}{
 		{
 			desc:            "both compose and container colors are specified",
-			composeColors:   []string{"91", "92", "93"},
+			namespaceColors: []string{"91", "92", "93"},
 			containerColors: []string{"31", "32", "33"},
 			want: [][2]*color.Color{
 				{color.New(color.FgHiRed), color.New(color.FgRed)},
@@ -26,7 +26,7 @@ func TestParseColors(t *testing.T) {
 		},
 		{
 			desc:            "only compose colors are specified",
-			composeColors:   []string{"91", "92", "93"},
+			namespaceColors: []string{"91", "92", "93"},
 			containerColors: []string{},
 			want: [][2]*color.Color{
 				{color.New(color.FgHiRed), color.New(color.FgHiRed)},
@@ -36,7 +36,7 @@ func TestParseColors(t *testing.T) {
 		},
 		{
 			desc:            "multiple attributes",
-			composeColors:   []string{"4;91"},
+			namespaceColors: []string{"4;91"},
 			containerColors: []string{"38;2;255;97;136"},
 			want: [][2]*color.Color{
 				{
@@ -47,7 +47,7 @@ func TestParseColors(t *testing.T) {
 		},
 		{
 			desc:            "spaces are ignored",
-			composeColors:   []string{"  91 ", "\t92\t"},
+			namespaceColors: []string{"  91 ", "\t92\t"},
 			containerColors: []string{},
 			want: [][2]*color.Color{
 				{color.New(color.FgHiRed), color.New(color.FgHiRed)},
@@ -57,26 +57,26 @@ func TestParseColors(t *testing.T) {
 		// error patterns
 		{
 			desc:            "only container colors are specified",
-			composeColors:   []string{},
+			namespaceColors: []string{},
 			containerColors: []string{"31", "32", "33"},
 			wantError:       true,
 		},
 		{
 			desc:            "both compose and container colors are empty",
-			composeColors:   []string{},
+			namespaceColors: []string{},
 			containerColors: []string{},
 			wantError:       true,
 		},
 		{
 			desc:            "invalid color",
-			composeColors:   []string{"a"},
+			namespaceColors: []string{"a"},
 			containerColors: []string{""},
 			wantError:       true,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.desc, func(t *testing.T) {
-			colorList, err := parseColors(tt.composeColors, tt.containerColors)
+			colorList, err := parseColors(tt.namespaceColors, tt.containerColors)
 
 			if tt.wantError {
 				if err == nil {

stern/docker_stern.go

@@ -34,7 +34,9 @@ func RunDocker(ctx context.Context, client *dockerclient.Client, config *DockerC
 			ContainerConfig{
 				target.Id,
 				target.Name,
+				target.ServiceName,
 				target.ComposeProject,
+				target.ContainerNumber,
 				target.Tty,
 			},
 			config.Template,