report

package
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 20, 2015 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// KeyBytesIngress is the aggregate metadata key for the total count of
	// ingress bytes.
	KeyBytesIngress = "ingress_bytes"
	// KeyBytesEgress is the aggregate metadata key for the total count of
	// egress bytes.
	KeyBytesEgress = "egress_bytes"
	// KeyMaxConnCountTCP is the aggregate metadata key for the maximum number
	// of simultaneous observed TCP connections in the window.
	KeyMaxConnCountTCP = "max_conn_count_tcp"
)
View Source 
const (
	// ScopeDelim separates the scope portion of an address from the address
	// string itself.
	ScopeDelim = ";"

	// IDDelim separates fields in a node ID.
	IDDelim = "|"
)
View Source 
const (
	// TheInternet is the ID that we assign to the super-node composed of all
	// remote nodes that have been squashed together.
	TheInternet = "theinternet"
)

Variables

View Source 
var MapFuncRegistry = map[string]MapFunc{
	"processpid":      ProcessPID,
	"processcgroup":   ProcessCgroup,
	"processname":     ProcessName,
	"networkhostname": NetworkHostname,
	"networkip":       NetworkIP,
}

MapFuncRegistry maps a string to a MapFunc.

Functions

func AddressIP 

func AddressIP(id string) net.IP

AddressIP translates "scope;ip" to the IP address. These are used by Network topologies.

func AddressIPPort 

func AddressIPPort(id string) net.IP

AddressIPPort translates "scope;ip;port" to the IP address. These are used by Process topologies.

Types

type Adjacency 

type Adjacency map[string]IDList

Adjacency is an adjacency-list encoding of the topology. Keys are node IDs, as produced by the relevant MappingFunc for the topology.

func (*Adjacency) Merge 

func (a *Adjacency) Merge(other Adjacency)

Merge merges another Adjacency list into the receiver.

type AggregateMetadata 

type AggregateMetadata map[string]int

AggregateMetadata is a composable version of an EdgeMetadata. It's used when we want to merge nodes/edges for any reason, or

Even though we base it on EdgeMetadata, we can apply it to nodes, by summing up (merging) all of the {ingress, egress} metadatas of the {incoming, outgoing} edges to the node.

func (*AggregateMetadata) Merge 

func (r *AggregateMetadata) Merge(other AggregateMetadata)

Merge adds the fields from AggregateMetadata to r. r must be initialized.

type ByID 

type ByID []RenderableNode

ByID is a sort interface for a RenderableNode slice.

func (ByID) Len 

func (r ByID) Len() int

func (ByID) Less 

func (r ByID) Less(i, j int) bool

func (ByID) Swap 

func (r ByID) Swap(i, j int)

type DetailedNode 

type DetailedNode struct {
	ID         string  `json:"id"`
	LabelMajor string  `json:"label_major"`
	LabelMinor string  `json:"label_minor,omitempty"`
	Pseudo     bool    `json:"pseudo,omitempty"`
	Tables     []Table `json:"tables"`
}

DetailedNode is the data type that's yielded to the JavaScript layer when we want deep information about an individual node.

type Diff 

type Diff struct {
	Add    []RenderableNode `json:"add"`
	Update []RenderableNode `json:"update"`
	Remove []string         `json:"remove"`
}

Diff is returned by TopoDiff. It represents the changes between two RenderableNode maps.

func TopoDiff 

func TopoDiff(a, b map[string]RenderableNode) Diff

TopoDiff gives you the diff to get from A to B.

type EdgeMetadata 

type EdgeMetadata struct {
	WithBytes    bool `json:"with_bytes,omitempty"`
	BytesIngress uint `json:"bytes_ingress,omitempty"` // dst -> src
	BytesEgress  uint `json:"bytes_egress,omitempty"`  // src -> dst

	WithConnCountTCP bool `json:"with_conn_count_tcp,omitempty"`
	MaxConnCountTCP  uint `json:"max_conn_count_tcp,omitempty"`
}

EdgeMetadata describes a superset of the metadata that probes can conceivably (and usefully) collect about an edge between two nodes in any topology.

func (*EdgeMetadata) Flatten 

func (m *EdgeMetadata) Flatten(other EdgeMetadata)

Flatten sums two EdgeMetadatas, their 'Window's should be the same size. The two EdgeMetadatas should represent different edges at the same time.

func (*EdgeMetadata) Merge 

func (m *EdgeMetadata) Merge(other EdgeMetadata)

Merge merges another EdgeMetadata into the receiver. The two edge metadatas should represent the same edge on different times.

func (EdgeMetadata) Transform 

func (md EdgeMetadata) Transform() AggregateMetadata

Transform calculates a AggregateMetadata from an EdgeMetadata.

type EdgeMetadatas 

type EdgeMetadatas map[string]EdgeMetadata

EdgeMetadatas collect metadata about each edge in a topology. Keys are a concatenation of node IDs.

func (*EdgeMetadatas) Merge 

func (e *EdgeMetadatas) Merge(other EdgeMetadatas)

Merge merges another EdgeMetadatas into the receiver. If other is from another probe this is the union of both metadatas. Keys present in both are summed.

type HostMetadata 

type HostMetadata struct {
	Timestamp                      time.Time
	Hostname                       string
	LocalNets                      []*net.IPNet
	OS                             string
	LoadOne, LoadFive, LoadFifteen float64
}

HostMetadata describes metadata that probes can collect about the host that they run on. It has a timestamp when the measurement was made.

func (*HostMetadata) UnmarshalJSON 

func (m *HostMetadata) UnmarshalJSON(data []byte) error

UnmarshalJSON is a custom JSON deserializer for HostMetadata to deal with the Localnets.

type HostMetadatas 

type HostMetadatas map[string]HostMetadata

HostMetadatas contains metadata about the host(s) represented in the Report.

func (HostMetadatas) LocalNets 

func (m HostMetadatas) LocalNets() []*net.IPNet

LocalNets gives the union of all local network IPNets for all hosts represented in the HostMetadatas.

func (*HostMetadatas) Merge 

func (e *HostMetadatas) Merge(other HostMetadatas)

Merge merges another HostMetadata into the receiver. It'll takes the lastest version if there are conflicts.

type IDAddresser 

type IDAddresser func(string) net.IP

IDAddresser is used to get the IP address from an addressID. Or nil.

type IDList 

type IDList []string

IDList is a list of string IDs, which are always sorted and without duplicates.

func NewIDList 

func NewIDList(ids ...string) IDList

NewIDList makes a new IDList.

func (IDList) Add 

func (a IDList) Add(ids ...string) IDList

Add is the only correct way to add ids to an IDList.

type MapFunc 

type MapFunc func(string, NodeMetadata, bool) (MappedNode, bool)

MapFunc is anything which can take an arbitrary NodeMetadata, which is always one-to-one with nodes in a topology, and return a specific representation of the referenced node, in the form of a node ID and a human-readable major and minor labels.

A single NodeMetadata can yield arbitrary many representations, including representations that reduce the cardinality of the set of nodes.

If the final output parameter is false, the node shall be omitted from the rendered topology.

type MappedNode 

type MappedNode struct {
	ID    string
	Major string
	Minor string
	Rank  string
}

MappedNode is returned by the MapFuncs.

func NetworkHostname 

func NetworkHostname(id string, m NodeMetadata, _ bool) (MappedNode, bool)

NetworkHostname takes a node NodeMetadata from a Network topology, and returns a representation based on the hostname. Major label is the hostname, the minor label is the domain, if any.

func NetworkIP 

func NetworkIP(id string, m NodeMetadata, _ bool) (MappedNode, bool)

NetworkIP takes a node NodeMetadata from a Network topology, and returns a representation based on the (scoped) IP. Major label is the IP, the Minor label is the hostname.

func ProcessCgroup 

func ProcessCgroup(id string, m NodeMetadata, grouped bool) (MappedNode, bool)

ProcessCgroup takes a node NodeMetadata from a Process topology, augmented with cgroup fields, and returns a representation based on the cgroup. If the cgroup is not present, it falls back to process name.

func ProcessName 

func ProcessName(id string, m NodeMetadata, grouped bool) (MappedNode, bool)

ProcessName takes a node NodeMetadata from a Process topology, and returns a representation based on the process name.

func ProcessPID 

func ProcessPID(id string, m NodeMetadata, grouped bool) (MappedNode, bool)

ProcessPID takes a node NodeMetadata from a Process topology, and returns a representation with the ID based on the process PID and the labels based on the process name.

type NodeMetadata 

type NodeMetadata map[string]string

NodeMetadata describes a superset of the metadata that probes can collect about a given node in a given topology. Right now it's a weakly-typed map, which should probably change (see comment on type MapFunc).

type NodeMetadatas 

type NodeMetadatas map[string]NodeMetadata

NodeMetadatas collect metadata about each node in a topology. Keys are node IDs.

func (*NodeMetadatas) Merge 

func (m *NodeMetadatas) Merge(other NodeMetadatas)

Merge merges another NodeMetadatas into the receiver.

type RenderableNode 

type RenderableNode struct {
	ID         string            `json:"id"`                    //
	LabelMajor string            `json:"label_major"`           // e.g. "process", human-readable
	LabelMinor string            `json:"label_minor,omitempty"` // e.g. "hostname", human-readable, optional
	Rank       string            `json:"rank"`                  // to help with the layout engine
	Pseudo     bool              `json:"pseudo,omitempty"`      // sort-of a placeholder node, for rendering purposes
	Adjacency  IDList            `json:"adjacency,omitempty"`   // Node IDs
	Origin     IDList            `json:"origin,omitempty"`      // Origin IDs
	Metadata   AggregateMetadata `json:"metadata"`              // sums
}

RenderableNode is the data type that's yielded to the JavaScript layer as an element of a topology. It should contain information that's relevant to rendering a node when there are many nodes visible at once.

type Report 

type Report struct {
	Process Topology
	// Transport Topology
	Network Topology
	HostMetadatas
}

Report is the internal structure produced and emitted by the probe, and operated-on (e.g. merged) by intermediaries and the app. The probe may fill in as many topologies as it's capable of producing, including none.

Process, [Transport,] and Network topologies are distinct because the data sources are distinct. That is, the Process topology can only be populated by extant connections between processes, but the Network topology may be populated from e.g. system-level data sources.

Since the data sources are fundamentally different for each topology, it might make sense to make them more distinct in the user interface.

func NewReport 

func NewReport() Report

NewReport makes a clean report, ready to Merge() other reports into.

func (*Report) Merge 

func (r *Report) Merge(other Report)

Merge merges another Report into the receiver.

func (Report) SquashRemote 

func (r Report) SquashRemote() Report

SquashRemote folds all remote nodes into a special supernode. It uses the LocalNets of the hosts in HostMetadata to determine which addresses are local.

type Row 

type Row struct {
	Key        string `json:"key"`                   // e.g. Ingress
	ValueMajor string `json:"value_major"`           // e.g. 25
	ValueMinor string `json:"value_minor,omitempty"` // e.g. KB/s
}

Row is a single entry in a Table dataset.

type Table 

type Table struct {
	Title   string `json:"title"`   // e.g. Bandwidth
	Numeric bool   `json:"numeric"` // should the major column be right-aligned?
	Rows    []Row  `json:"rows"`
}

Table is a dataset associated with a node. It will be displayed in the detail panel when a user clicks on a node.

type Topology 

type Topology struct {
	Adjacency
	EdgeMetadatas
	NodeMetadatas
}

Topology describes a specific view of a network. It consists of nodes and edges, represented by Adjacency, and metadata about those nodes and edges, represented by EdgeMetadatas and NodeMetadatas respectively.

func NewTopology 

func NewTopology() Topology

NewTopology gives you a Topology.

func Squash 

func Squash(t Topology, f IDAddresser, localNets []*net.IPNet) Topology

Squash takes a Topology, and folds all remote nodes into a supernode.

func (Topology) EdgeMetadata 

func (t Topology) EdgeMetadata(f MapFunc, grouped bool, srcRenderableID, dstRenderableID string) EdgeMetadata

EdgeMetadata gives the metadata of an edge from the perspective of the srcRenderableID. Since an edgeID can have multiple edges on the address level, it uses the supplied mapping function to translate address IDs to renderable node (mapped) IDs.

func (*Topology) Merge 

func (t *Topology) Merge(other Topology)

Merge merges another Topology into the receiver.

func (Topology) RenderBy 

func (t Topology) RenderBy(f MapFunc, grouped bool) map[string]RenderableNode

RenderBy transforms a given Topology into a set of RenderableNodes, which the UI will render collectively as a graph. Note that a RenderableNode will always be rendered with other nodes, and therefore contains limited detail.

RenderBy takes a a MapFunc, which defines how to group and label nodes. If grouped is true, nodes that belong to the same "class" will be merged.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.