use constants for the topology names in Parents/metadata/metrics

2026-07-21 22:36:39 +00:00 · 2016-01-18 10:56:36 +00:00
parent 3cda328976
commit e30c9dc264
18 changed files with 76 additions and 63 deletions
--- a/probe/docker/container.go
+++ b/probe/docker/container.go
@@ -334,7 +334,7 @@ func (c *container) GetNode(hostID string, localAddrs []net.IP) report.Node {
 	).WithMetrics(
 		c.metrics(),
 	).WithParents(report.Sets{
-		"container_image": report.MakeStringSet(report.MakeContainerImageNodeID(c.container.Image)),
+		report.ContainerImage: report.MakeStringSet(report.MakeContainerImageNodeID(c.container.Image)),
 	})

 	if c.container.State.Paused {
--- a/probe/docker/container_test.go
+++ b/probe/docker/container_test.go
@@ -93,7 +93,7 @@ func TestContainer(t *testing.T) {
 		"cpu_total_usage": report.MakeMetric(),
 		"memory_usage":    report.MakeMetric().Add(now, 12345),
 	}).WithParents(report.Sets{
-		"container_image": report.MakeStringSet(report.MakeContainerImageNodeID("baz")),
+		report.ContainerImage: report.MakeStringSet(report.MakeContainerImageNodeID("baz")),
 	})
 	test.Poll(t, 100*time.Millisecond, want, func() interface{} {
 		node := c.GetNode("scope", []net.IP{})
--- a/probe/docker/tagger.go
+++ b/probe/docker/tagger.go
@@ -85,8 +85,8 @@ func (t *Tagger) tag(tree process.Tree, topology *report.Topology) {
 		topology.AddNode(nodeID, report.MakeNodeWith(map[string]string{
 			ContainerID: c.ID(),
 		}).WithParents(report.Sets{
-			"container":       report.MakeStringSet(report.MakeContainerNodeID(c.ID())),
-			"container_image": report.MakeStringSet(report.MakeContainerImageNodeID(c.Image())),
+			report.Container:      report.MakeStringSet(report.MakeContainerNodeID(c.ID())),
+			report.ContainerImage: report.MakeStringSet(report.MakeContainerImageNodeID(c.Image())),
 		}))
 	}
 }
--- a/probe/docker/tagger_test.go
+++ b/probe/docker/tagger_test.go
@@ -41,8 +41,8 @@ func TestTagger(t *testing.T) {
 		wantNode   = report.MakeNodeWith(map[string]string{
 			docker.ContainerID: "ping",
 		}).WithParents(report.Sets{
-			"container":       report.MakeStringSet(report.MakeContainerNodeID("ping")),
-			"container_image": report.MakeStringSet(report.MakeContainerImageNodeID("baz")),
+			report.Container:      report.MakeStringSet(report.MakeContainerNodeID("ping")),
+			report.ContainerImage: report.MakeStringSet(report.MakeContainerImageNodeID("baz")),
 		})
 	)

--- a/probe/host/tagger.go
+++ b/probe/host/tagger.go
@@ -32,7 +32,7 @@ func (t Tagger) Tag(r report.Report) (report.Report, error) {
 			report.ProbeID:    t.probeID,
 		}
 		parents = report.Sets{
-			"host": report.MakeStringSet(t.hostNodeID),
+			report.Host: report.MakeStringSet(t.hostNodeID),
 		}
 	)

--- a/probe/host/tagger_test.go
+++ b/probe/host/tagger_test.go
@@ -23,7 +23,7 @@ func TestTagger(t *testing.T) {
 		report.HostNodeID: report.MakeHostNodeID(hostID),
 		report.ProbeID:    probeID,
 	}).WithParents(report.Sets{
-		"host": report.MakeStringSet(report.MakeHostNodeID(hostID)),
+		report.Host: report.MakeStringSet(report.MakeHostNodeID(hostID)),
 	}))
 	rpt, _ := host.NewTagger(hostID, probeID).Tag(r)
 	have := rpt.Process.Nodes[endpointNodeID].Copy()
--- a/probe/kubernetes/pod.go
+++ b/probe/kubernetes/pod.go
@@ -90,7 +90,7 @@ func (p *pod) GetNode() report.Node {
 			continue
 		}
 		n = n.WithParents(report.Sets{
-			"service": report.MakeStringSet(report.MakeServiceNodeID(p.Namespace(), segments[1])),
+			report.Service: report.MakeStringSet(report.MakeServiceNodeID(p.Namespace(), segments[1])),
 		})
 	}
 	return n
--- a/probe/kubernetes/reporter.go
+++ b/probe/kubernetes/reporter.go
@@ -65,7 +65,7 @@ func (r *Reporter) podTopology(services []Service) (report.Topology, report.Topo
 			PodID:     p.ID(),
 			Namespace: p.Namespace(),
 		}).WithParents(report.Sets{
-			"pod": report.MakeStringSet(nodeID),
+			report.Pod: report.MakeStringSet(nodeID),
 		})
 		for _, containerID := range p.ContainerIDs() {
 			containers.AddNode(report.MakeContainerNodeID(containerID), container)
--- a/probe/kubernetes/reporter_test.go
+++ b/probe/kubernetes/reporter_test.go
@@ -120,7 +120,7 @@ func TestReporter(t *testing.T) {
 		kubernetes.PodContainerIDs: "container1 container2",
 		kubernetes.ServiceIDs:      "ping/pongservice",
 	}).WithParents(report.Sets{
-		"service": report.MakeStringSet(serviceID),
+		report.Service: report.MakeStringSet(serviceID),
 	})).AddNode(pod2ID, report.MakeNodeWith(map[string]string{
 		kubernetes.PodID:           "ping/pong-b",
 		kubernetes.PodName:         "pong-b",
@@ -129,7 +129,7 @@ func TestReporter(t *testing.T) {
 		kubernetes.PodContainerIDs: "container3 container4",
 		kubernetes.ServiceIDs:      "ping/pongservice",
 	}).WithParents(report.Sets{
-		"service": report.MakeStringSet(serviceID),
+		report.Service: report.MakeStringSet(serviceID),
 	}))
 	want.Service = report.MakeTopology().AddNode(serviceID, report.MakeNodeWith(map[string]string{
 		kubernetes.ServiceID:      "ping/pongservice",
@@ -141,22 +141,22 @@ func TestReporter(t *testing.T) {
 		kubernetes.PodID:     "ping/pong-a",
 		kubernetes.Namespace: "ping",
 	}).WithParents(report.Sets{
-		"pod": report.MakeStringSet(pod1ID),
+		report.Pod: report.MakeStringSet(pod1ID),
 	})).AddNode(report.MakeContainerNodeID("container2"), report.MakeNodeWith(map[string]string{
 		kubernetes.PodID:     "ping/pong-a",
 		kubernetes.Namespace: "ping",
 	}).WithParents(report.Sets{
-		"pod": report.MakeStringSet(pod1ID),
+		report.Pod: report.MakeStringSet(pod1ID),
 	})).AddNode(report.MakeContainerNodeID("container3"), report.MakeNodeWith(map[string]string{
 		kubernetes.PodID:     "ping/pong-b",
 		kubernetes.Namespace: "ping",
 	}).WithParents(report.Sets{
-		"pod": report.MakeStringSet(pod2ID),
+		report.Pod: report.MakeStringSet(pod2ID),
 	})).AddNode(report.MakeContainerNodeID("container4"), report.MakeNodeWith(map[string]string{
 		kubernetes.PodID:     "ping/pong-b",
 		kubernetes.Namespace: "ping",
 	}).WithParents(report.Sets{
-		"pod": report.MakeStringSet(pod2ID),
+		report.Pod: report.MakeStringSet(pod2ID),
 	}))

 	reporter := kubernetes.NewReporter(mockClientInstance)
--- a/probe/probe_internal_test.go
+++ b/probe/probe_internal_test.go
@@ -33,8 +33,8 @@ func TestApply(t *testing.T) {
 		from report.Topology
 		via  string
 	}{
-		{endpointNode.Merge(report.MakeNode().WithID("c").WithTopology("endpoint")), r.Endpoint, endpointNodeID},
-		{addressNode.Merge(report.MakeNode().WithID("d").WithTopology("address")), r.Address, addressNodeID},
+		{endpointNode.Merge(report.MakeNode().WithID("c").WithTopology(report.Endpoint)), r.Endpoint, endpointNodeID},
+		{addressNode.Merge(report.MakeNode().WithID("d").WithTopology(report.Address)), r.Address, addressNodeID},
 	} {
 		if want, have := tuple.want, tuple.from.Nodes[tuple.via]; !reflect.DeepEqual(want, have) {
 			t.Errorf("want %+v, have %+v", want, have)
--- a/probe/topology_tagger.go
+++ b/probe/topology_tagger.go
@@ -17,15 +17,15 @@ func (topologyTagger) Name() string { return "Topology" }
 // Tag implements Tagger
 func (topologyTagger) Tag(r report.Report) (report.Report, error) {
 	for name, t := range map[string]*report.Topology{
-		"endpoint":        &(r.Endpoint),
-		"address":         &(r.Address),
-		"process":         &(r.Process),
-		"container":       &(r.Container),
-		"container_image": &(r.ContainerImage),
-		"pod":             &(r.Pod),
-		"service":         &(r.Service),
-		"host":            &(r.Host),
-		"overlay":         &(r.Overlay),
+		report.Endpoint:       &(r.Endpoint),
+		report.Address:        &(r.Address),
+		report.Process:        &(r.Process),
+		report.Container:      &(r.Container),
+		report.ContainerImage: &(r.ContainerImage),
+		report.Pod:            &(r.Pod),
+		report.Service:        &(r.Service),
+		report.Host:           &(r.Host),
+		report.Overlay:        &(r.Overlay),
 	} {
 		for id, node := range t.Nodes {
 			t.AddNode(id, node.WithID(id).WithTopology(name))
--- a/render/detailed/metadata.go
+++ b/render/detailed/metadata.go
@@ -70,11 +70,11 @@ func (m MetadataRow) Copy() MetadataRow {
 // an origin ID, which is (optimistically) a node ID in one of our topologies.
 func NodeMetadata(n report.Node) []MetadataRow {
 	renderers := map[string]func(report.Node) []MetadataRow{
-		"process":         processNodeMetadata,
-		"container":       containerNodeMetadata,
-		"container_image": containerImageNodeMetadata,
-		"pod":             podNodeMetadata,
-		"host":            hostNodeMetadata,
+		report.Process:        processNodeMetadata,
+		report.Container:      containerNodeMetadata,
+		report.ContainerImage: containerImageNodeMetadata,
+		report.Pod:            podNodeMetadata,
+		report.Host:           hostNodeMetadata,
 	}
 	if renderer, ok := renderers[n.Topology]; ok {
 		return renderer(n)
--- a/render/detailed/metadata_test.go
+++ b/render/detailed/metadata_test.go
@@ -22,7 +22,7 @@ func TestNodeMetadata(t *testing.T) {
 			node: report.MakeNodeWith(map[string]string{
 				docker.ContainerID:            fixture.ClientContainerID,
 				docker.LabelPrefix + "label1": "label1value",
-			}).WithTopology("container").WithSets(report.Sets{
+			}).WithTopology(report.Container).WithSets(report.Sets{
 				docker.ContainerIPs: report.MakeStringSet("10.10.10.0/24", "10.10.10.1/24"),
 			}).WithLatest(docker.ContainerState, fixture.Now, docker.StateRunning),
 			want: []detailed.MetadataRow{
--- a/render/detailed/metrics.go
+++ b/render/detailed/metrics.go
@@ -85,9 +85,9 @@ func toFixed(num float64, precision int) float64 {
 // an origin ID, which is (optimistically) a node ID in one of our topologies.
 func NodeMetrics(n report.Node) []MetricRow {
 	renderers := map[string]func(report.Node) []MetricRow{
-		"process":   processNodeMetrics,
-		"container": containerNodeMetrics,
-		"host":      hostNodeMetrics,
+		report.Process:   processNodeMetrics,
+		report.Container: containerNodeMetrics,
+		report.Host:      hostNodeMetrics,
 	}
 	if renderer, ok := renderers[n.Topology]; ok {
 		return renderer(n)
--- a/render/detailed/node.go
+++ b/render/detailed/node.go
@@ -93,11 +93,11 @@ var (
 		topologyID string
 		NodeSummaryGroup
 	}{
-		{"host", NodeSummaryGroup{TopologyID: "hosts", Label: "Hosts", Columns: []string{host.CPUUsage, host.MemUsage}}},
-		{"pod", NodeSummaryGroup{TopologyID: "pods", Label: "Pods", Columns: []string{}}},
-		{"container_image", NodeSummaryGroup{TopologyID: "containers-by-image", Label: "Container Images", Columns: []string{}}},
-		{"container", NodeSummaryGroup{TopologyID: "containers", Label: "Containers", Columns: []string{docker.CPUTotalUsage, docker.MemoryUsage}}},
-		{"process", NodeSummaryGroup{TopologyID: "applications", Label: "Applications", Columns: []string{process.PID, process.CPUUsage, process.MemoryUsage}}},
+		{report.Host, NodeSummaryGroup{TopologyID: "hosts", Label: "Hosts", Columns: []string{host.CPUUsage, host.MemUsage}}},
+		{report.Pod, NodeSummaryGroup{TopologyID: "pods", Label: "Pods", Columns: []string{}}},
+		{report.ContainerImage, NodeSummaryGroup{TopologyID: "containers-by-image", Label: "Container Images", Columns: []string{}}},
+		{report.Container, NodeSummaryGroup{TopologyID: "containers", Label: "Containers", Columns: []string{docker.CPUTotalUsage, docker.MemoryUsage}}},
+		{report.Process, NodeSummaryGroup{TopologyID: "applications", Label: "Applications", Columns: []string{process.PID, process.CPUUsage, process.MemoryUsage}}},
 	}
 )

@@ -140,11 +140,11 @@ func parents(r report.Report, n render.RenderableNode) (result []Parent) {
 		report.Topology
 		render func(report.Node) Parent
 	}{
-		"container":       {r.Container, containerParent},
-		"pod":             {r.Pod, podParent},
-		"service":         {r.Service, serviceParent},
-		"container_image": {r.ContainerImage, containerImageParent},
-		"host":            {r.Host, hostParent},
+		report.Container:      {r.Container, containerParent},
+		report.Pod:            {r.Pod, podParent},
+		report.Service:        {r.Service, serviceParent},
+		report.ContainerImage: {r.ContainerImage, containerImageParent},
+		report.Host:           {r.Host, hostParent},
 	}
 	topologyIDs := []string{}
 	for topologyID := range topologies {
--- a/render/short_lived_connections_test.go
+++ b/render/short_lived_connections_test.go
@@ -37,13 +37,13 @@ var (
 					endpoint.Addr:        randomIP,
 					endpoint.Port:        randomPort,
 					endpoint.Conntracked: "true",
-				}).WithAdjacent(serverEndpointNodeID).WithID(randomEndpointNodeID).WithTopology("endpoint"),
+				}).WithAdjacent(serverEndpointNodeID).WithID(randomEndpointNodeID).WithTopology(report.Endpoint),

 				serverEndpointNodeID: report.MakeNode().WithMetadata(map[string]string{
 					endpoint.Addr:        serverIP,
 					endpoint.Port:        serverPort,
 					endpoint.Conntracked: "true",
-				}).WithID(serverEndpointNodeID).WithTopology("endpoint"),
+				}).WithID(serverEndpointNodeID).WithTopology(report.Endpoint),
 			},
 		},
 		Container: report.Topology{
@@ -55,7 +55,7 @@ var (
 				}).WithSets(report.Sets{
 					docker.ContainerIPs:   report.MakeStringSet(containerIP),
 					docker.ContainerPorts: report.MakeStringSet(fmt.Sprintf("%s:%s->%s/tcp", serverIP, serverPort, serverPort)),
-				}).WithID(containerNodeID).WithTopology("container"),
+				}).WithID(containerNodeID).WithTopology(report.Container),
 			},
 		},
 		Host: report.Topology{
@@ -64,7 +64,7 @@ var (
 					report.HostNodeID: serverHostNodeID,
 				}).WithSets(report.Sets{
 					host.LocalNetworks: report.MakeStringSet("192.168.0.0/16"),
-				}).WithID(serverHostNodeID).WithTopology("host"),
+				}).WithID(serverHostNodeID).WithTopology(report.Host),
 			},
 		},
 	}
--- a/report/report.go
+++ b/report/report.go
@@ -6,6 +6,19 @@ import (
 	"time"
 )

+// Names of the various topologies.
+const (
+	Endpoint       = "endpoint"
+	Address        = "address"
+	Process        = "process"
+	Container      = "container"
+	Pod            = "pod"
+	Service        = "service"
+	ContainerImage = "container_image"
+	Host           = "host"
+	Overlay        = "overlay"
+)
+
 // Report is the core data type. It's produced by probes, and consumed and
 // stored by apps. It's composed of multiple topologies, each representing
 // a different (related, but not equivalent) view of the network.
--- a/test/fixture/report_fixture.go
+++ b/test/fixture/report_fixture.go
@@ -205,7 +205,7 @@ var (
 					process.Name:       Client1Name,
 					docker.ContainerID: ClientContainerID,
 					report.HostNodeID:  ClientHostNodeID,
-				}).WithID(ClientProcess1NodeID).WithTopology("process").WithParents(report.Sets{
+				}).WithID(ClientProcess1NodeID).WithTopology(report.Process).WithParents(report.Sets{
 					"host":            report.MakeStringSet(ClientHostNodeID),
 					"container":       report.MakeStringSet(ClientContainerNodeID),
 					"container_image": report.MakeStringSet(ClientContainerImageNodeID),
@@ -218,7 +218,7 @@ var (
 					process.Name:       Client2Name,
 					docker.ContainerID: ClientContainerID,
 					report.HostNodeID:  ClientHostNodeID,
-				}).WithID(ClientProcess2NodeID).WithTopology("process").WithParents(report.Sets{
+				}).WithID(ClientProcess2NodeID).WithTopology(report.Process).WithParents(report.Sets{
 					"host":            report.MakeStringSet(ClientHostNodeID),
 					"container":       report.MakeStringSet(ClientContainerNodeID),
 					"container_image": report.MakeStringSet(ClientContainerImageNodeID),
@@ -228,7 +228,7 @@ var (
 					process.Name:       ServerName,
 					docker.ContainerID: ServerContainerID,
 					report.HostNodeID:  ServerHostNodeID,
-				}).WithID(ServerProcessNodeID).WithTopology("process").WithParents(report.Sets{
+				}).WithID(ServerProcessNodeID).WithTopology(report.Process).WithParents(report.Sets{
 					"host":            report.MakeStringSet(ServerHostNodeID),
 					"container":       report.MakeStringSet(ServerContainerNodeID),
 					"container_image": report.MakeStringSet(ServerContainerImageNodeID),
@@ -237,7 +237,7 @@ var (
 					process.PID:       NonContainerPID,
 					process.Name:      NonContainerName,
 					report.HostNodeID: ServerHostNodeID,
-				}).WithID(NonContainerProcessNodeID).WithTopology("process").WithParents(report.Sets{
+				}).WithID(NonContainerProcessNodeID).WithTopology(report.Process).WithParents(report.Sets{
 					"host": report.MakeStringSet(ServerHostNodeID),
 				}),
 			},
@@ -252,7 +252,7 @@ var (
 					docker.LabelPrefix + "io.kubernetes.pod.name": ClientPodID,
 					kubernetes.PodID:                              ClientPodID,
 					kubernetes.Namespace:                          KubernetesNamespace,
-				}).WithLatest(docker.ContainerState, Now, docker.StateRunning).WithID(ClientContainerNodeID).WithTopology("container").WithParents(report.Sets{
+				}).WithLatest(docker.ContainerState, Now, docker.StateRunning).WithID(ClientContainerNodeID).WithTopology(report.Container).WithParents(report.Sets{
 					"host":            report.MakeStringSet(ClientHostNodeID),
 					"container_image": report.MakeStringSet(ClientContainerImageNodeID),
 					"pod":             report.MakeStringSet(ClientPodID),
@@ -272,7 +272,7 @@ var (
 					docker.LabelPrefix + "io.kubernetes.pod.name":           ServerPodID,
 					kubernetes.PodID:                                        ServerPodID,
 					kubernetes.Namespace:                                    KubernetesNamespace,
-				}).WithLatest(docker.ContainerState, Now, docker.StateRunning).WithID(ServerContainerNodeID).WithTopology("container").WithParents(report.Sets{
+				}).WithLatest(docker.ContainerState, Now, docker.StateRunning).WithID(ServerContainerNodeID).WithTopology(report.Container).WithParents(report.Sets{
 					"host":            report.MakeStringSet(ServerHostNodeID),
 					"container_image": report.MakeStringSet(ServerContainerImageNodeID),
 					"pod":             report.MakeStringSet(ServerPodID),
@@ -290,7 +290,7 @@ var (
 					report.HostNodeID: ClientHostNodeID,
 				}).WithParents(report.Sets{
 					"host": report.MakeStringSet(ClientHostNodeID),
-				}).WithID(ClientContainerImageNodeID).WithTopology("container_image"),
+				}).WithID(ClientContainerImageNodeID).WithTopology(report.ContainerImage),
 				ServerContainerImageNodeID: report.MakeNodeWith(map[string]string{
 					docker.ImageID:              ServerContainerImageID,
 					docker.ImageName:            ServerContainerImageName,
@@ -299,7 +299,7 @@ var (
 					docker.LabelPrefix + "foo2": "bar2",
 				}).WithParents(report.Sets{
 					"host": report.MakeStringSet(ServerHostNodeID),
-				}).WithID(ServerContainerImageNodeID).WithTopology("container_image"),
+				}).WithID(ServerContainerImageNodeID).WithTopology(report.ContainerImage),
 			},
 		},
 		Address: report.Topology{
@@ -339,7 +339,7 @@ var (
 					"host_name":       ClientHostName,
 					"os":              "Linux",
 					report.HostNodeID: ClientHostNodeID,
-				}).WithID(ClientHostNodeID).WithTopology("host").WithSets(report.Sets{
+				}).WithID(ClientHostNodeID).WithTopology(report.Host).WithSets(report.Sets{
 					host.LocalNetworks: report.MakeStringSet("10.10.10.0/24"),
 				}).WithMetrics(report.Metrics{
 					host.CPUUsage: CPUMetric,
@@ -352,7 +352,7 @@ var (
 					"host_name":       ServerHostName,
 					"os":              "Linux",
 					report.HostNodeID: ServerHostNodeID,
-				}).WithID(ServerHostNodeID).WithTopology("host").WithSets(report.Sets{
+				}).WithID(ServerHostNodeID).WithTopology(report.Host).WithSets(report.Sets{
 					host.LocalNetworks: report.MakeStringSet("10.10.10.0/24"),
 				}).WithMetrics(report.Metrics{
 					host.CPUUsage: CPUMetric,
@@ -371,7 +371,7 @@ var (
 					kubernetes.Namespace:       KubernetesNamespace,
 					kubernetes.PodContainerIDs: ClientContainerID,
 					kubernetes.ServiceIDs:      ServiceID,
-				}).WithID(ClientPodNodeID).WithTopology("pod").WithParents(report.Sets{
+				}).WithID(ClientPodNodeID).WithTopology(report.Pod).WithParents(report.Sets{
 					"host":    report.MakeStringSet(ClientHostNodeID),
 					"service": report.MakeStringSet(ServiceID),
 				}),
@@ -381,7 +381,7 @@ var (
 					kubernetes.Namespace:       KubernetesNamespace,
 					kubernetes.PodContainerIDs: ServerContainerID,
 					kubernetes.ServiceIDs:      ServiceID,
-				}).WithID(ServerPodNodeID).WithTopology("pod").WithParents(report.Sets{
+				}).WithID(ServerPodNodeID).WithTopology(report.Pod).WithParents(report.Sets{
 					"host":    report.MakeStringSet(ServerHostNodeID),
 					"service": report.MakeStringSet(ServiceID),
 				}),
@@ -393,7 +393,7 @@ var (
 					kubernetes.ServiceID:   ServiceID,
 					kubernetes.ServiceName: "pongservice",
 					kubernetes.Namespace:   "ping",
-				}).WithID(ServiceNodeID).WithTopology("service"),
+				}).WithID(ServiceNodeID).WithTopology(report.Service),
 			},
 		},
 		Sampling: report.Sampling{