docker_

#!/usr/bin/env python
import docker
import re
import sys
import collections
import os

# Constants
DOCKER_COMPOSE_LABEL = 'com.docker.compose.project'
NANO_SECONDS_IN_SECOND = 1000000000

# Get Docker client
client = docker.from_env()

### Functions ###
# Only allowed characters for Munin field name
def makeFieldName(name):
	return re.sub(r'[^A-Za-z0-9_]', '_', name)

# Prevent line wrap for i/o Munin graphs
def truncate(string, length = 8, replace = '..'):
	if len(string) > length:
		size = (length - len(replace)) / 2
		newString = string[:size] + replace + string[-size:]
		return newString
	else:
		return string

def readFile(filename):
	try:
		with open(filename, 'r') as f:
			return f.read()
	except:
		return False

def getDirSizeRecursive(dir):
	size = 0
	for item in os.listdir(dir):
		itempath = os.path.join(dir, item)
		if os.path.isfile(itempath):
			size += os.path.getsize(itempath)
		elif os.path.isdir(itempath):
			size += getDirSizeRecursive(itempath)
	return size

def getComposeContainers():
	projects = {}
	for container in client.containers.list():
		if not DOCKER_COMPOSE_LABEL in container.labels:
			continue

		project = container.labels[DOCKER_COMPOSE_LABEL]
		if not project in projects:
			projects[project] = []

		projects[project].append(container)
	return projects

## Obtain Stats Functions ##
def getContainerCpu(containerId):
	filename = '/sys/fs/cgroup/cpuacct/docker/%s/cpuacct.usage' % (containerId)
	file = readFile(filename)
	if file == False:
		return False

	usage = long(file) * 100 # To percent
	return usage

def getContainerMemory(containerId, includeCache):
	# Get total memory
	filename = '/sys/fs/cgroup/memory/docker/%s/memory.usage_in_bytes' % (containerId)
	file = readFile(filename)
	if file == False:
		return False
	bytes = long(file)

	if not includeCache:
		# Substract cache
		filename = '/sys/fs/cgroup/memory/docker/%s/memory.stat' % (containerId)
		file = readFile(filename)
		if file == False:
			return False

		m = re.search(r'^cache (\d+)$', file, flags = re.MULTILINE)
		if m:
			cacheBytes = long(m.group(1))
			bytes -= cacheBytes

	return bytes

def getContainerBlockIO(containerId):
	def getBlockIOStat(file, name):
		m = re.search(r'%s (\d+)$' % (name), file, flags = re.MULTILINE)
		if m:
			return long(m.group(1))
		return 0

	filename = '/sys/fs/cgroup/blkio/docker/%s/blkio.throttle.io_service_bytes' % (containerId)
	file = readFile(filename)
	if file == False:
		return False

	return {
		'write': getBlockIOStat(file, 'Write'),
		'read': getBlockIOStat(file, 'Read'),
	}

def getContainerNetIO(container):
	def getNetIOStat(field):
		if not field.isdigit():
			return 0
		return long(field) * 8

	# Get container processes
	top = container.top()
	if len(top['Processes']) == 0:
		return False

	process = top['Processes'][0] # All processes have the same stats
	pid = process[1]

	file = readFile('/proc/%s/net/dev' % (pid))
	if file == False:
		return False

	netio = {
		'rxBits': 0,
		'txBits': 0,
	}
	for line in file.splitlines():
		parts = line.split()

		# Invalid lines
		if len(parts) == 0 or len(parts) < 10:
			continue

		# No local interfaces
		if parts[0] == 'lo:' or 'bond' in parts[0]:
			continue

		netio['rxBits'] += getNetIOStat(parts[1])
		netio['txBits'] += getNetIOStat(parts[9])

	return netio

### Graph Functions ###
def funcCpu():
	# Config
	munin.setOption('graph_title', 'Docker container CPU usage')
	munin.setOption('graph_args', '--base 1000 -r --lower-limit 0')
	munin.setOption('graph_vlabel', '%')
	munin.setOption('graph_scale', 'no')
	munin.setOption('graph_period', 'second')

	# Fields
	for container in client.containers.list():
		name = container.name
		field = makeFieldName(name)

		munin.addField(field, {
			'label': name,
			'min': 0,
			'type': 'DERIVE',
			'cdef': '%s,%d,/' % (field, NANO_SECONDS_IN_SECOND),
		})

		# Values
		if munin.needValues:
			usage = getContainerCpu(container.id)
			if usage == False:
				continue

			munin.setFieldValue(field, usage)

def funcMemoryWithCache():
	return funcMemory(True)

def funcMemoryNoCache():
	return funcMemory(False)

def funcMemory(includeCache):
	# Config
	if includeCache:
		title = 'Docker container memory usage'
	else:
		title = 'Docker container memory usage (no cache)'

	munin.setOption('graph_title', title)
	munin.setOption('graph_args', '--base 1024')
	munin.setOption('graph_vlabel', 'Bytes')

	# Fields
	for container in client.containers.list():
		name = container.name
		field = makeFieldName(name)

		munin.addField(field, {
			'label': name,
		})

		# Values
		if munin.needValues:
			bytes = getContainerMemory(container.id, includeCache)
			if bytes == False:
				continue

			munin.setFieldValue(field, bytes)

def funcBlockIO():
	# Config
	munin.setOption('graph_title', 'Docker container disk throughput')
	munin.setOption('graph_args', '--base 1024')
	munin.setOption('graph_vlabel', 'Bytes read (-) / write (+) per second')

	# Fields
	for container in client.containers.list():
		name = container.name
		field = makeFieldName(container.name)
		fieldRead = '%s_read' % (field)
		fieldWrite = '%s_write' % (field)

		munin.addField(fieldRead, {
			'label': truncate(name),
			'min': '0',
			'type': 'DERIVE',
			'graph': 'no',
		})
		munin.addField(fieldWrite, {
			'label': truncate(name),
			'min': '0',
			'type': 'DERIVE',
			'negative': fieldRead,
		})

		# Values
		if munin.needValues:
			blockio = getContainerBlockIO(container.id)
			if blockio == False:
				continue

			munin.setFieldValue(fieldWrite, blockio['write'])
			munin.setFieldValue(fieldRead, blockio['read'])

def funcNetIO():
	# Config
	munin.setOption('graph_title', 'Docker container traffic')
	munin.setOption('graph_args', '--base 1000')
	munin.setOption('graph_vlabel', 'Bits in (-) / out (+) per second')

	# Fields
	for container in client.containers.list():
		name = truncate(container.name)
		field = makeFieldName(container.name)
		fieldRx = '%s_rx' % (field)
		fieldTx = '%s_tx' % (field)

		munin.addField(fieldRx, {
			'label': name,
			'min': '0',
			'type': 'DERIVE',
			'graph': 'no',
		})
		munin.addField(fieldTx, {
			'label': name,
			'min': '0',
			'type': 'DERIVE',
			'negative': fieldRx,
		})

		# Values
		if munin.needValues:
			netio = getContainerNetIO(container)
			if netio == False:
				continue

			munin.setFieldValue(fieldRx, netio['rxBits'])
			munin.setFieldValue(fieldTx, netio['txBits'])

def funcVolumes():
	# Config
	munin.setOption('graph_title', 'Docker volume size')
	munin.setOption('graph_args', '--base 1024')
	munin.setOption('graph_vlabel', 'Bytes')

	# Fields
	for volume in client.volumes.list():
		# Only handle named volumes
		if re.match(r'^[a-f0-9]{64}$', volume.id):
			continue

		field = makeFieldName(volume.name)
		munin.addField(field, {
			'label': volume.name,
		})

		# Values
		if munin.needValues:
			size = 0
			if 'Mountpoint' in volume.attrs:
				try:
					size = getDirSizeRecursive(volume.attrs['Mountpoint'])
				except:
					pass
			munin.setFieldValue(field, size)

def funcComposeCpu():
	# Config
	munin.setOption('graph_title', 'Docker compose CPU usage')
	munin.setOption('graph_args', '--base 1000 -r --lower-limit 0')
	munin.setOption('graph_vlabel', '%')
	munin.setOption('graph_scale', 'no')
	munin.setOption('graph_period', 'second')

	# Fields
	projects = getComposeContainers()
	for project in projects:
		field = makeFieldName(project)
		munin.addField(field, {
			'label': project,
			'min': 0,
			'type': 'DERIVE',
			'cdef': '%s,%d,/' % (field, NANO_SECONDS_IN_SECOND),
		})

		# Values
		if munin.needValues:
			totalUsage = 0
			for container in projects[project]:
				usage = getContainerCpu(container.id)
				if usage == False:
					continue

				totalUsage += usage
			munin.setFieldValue(field, totalUsage)

def funcComposeMemoryWithCache():
	return funcComposeMemory(True)

def funcComposeMemoryNoCache():
	return funcComposeMemory(False)

def funcComposeMemory(includeCache):
	# Config
	if includeCache:
		title = 'Docker compose memory usage'
	else:
		title = 'Docker compose memory usage (no cache)'

	munin.setOption('graph_title', title)
	munin.setOption('graph_args', '--base 1024')
	munin.setOption('graph_vlabel', 'Bytes')

	# Fields
	projects = getComposeContainers()
	for project in projects:
		field = makeFieldName(project)
		munin.addField(field, {
			'label': project,
		})

		# Values
		if munin.needValues:
			totalBytes = 0
			for container in projects[project]:
				bytes = getContainerMemory(container.id, includeCache)
				if bytes == False:
					continue

				totalBytes += bytes
			munin.setFieldValue(field, totalBytes)

def funcComposeBlockIO():
	# Config
	munin.setOption('graph_title', 'Docker compose disk throughput')
	munin.setOption('graph_args', '--base 1024')
	munin.setOption('graph_vlabel', 'Bytes read (-) / write (+) per second')

	# Fields
	projects = getComposeContainers()
	for project in projects:
		field = makeFieldName(project)
		fieldRead = '%s_read' % (field)
		fieldWrite = '%s_write' % (field)

		munin.addField(fieldRead, {
			'label': truncate(project),
			'min': '0',
			'type': 'DERIVE',
			'graph': 'no',
		})
		munin.addField(fieldWrite, {
			'label': truncate(project),
			'min': '0',
			'type': 'DERIVE',
			'negative': fieldRead,
		})

		# Values
		if munin.needValues:
			writeBytes = 0
			readBytes = 0
			for container in projects[project]:
				blockio = getContainerBlockIO(container.id)
				if blockio == False:
					continue

				writeBytes += blockio['write']
				readBytes += blockio['read']

			munin.setFieldValue(fieldWrite, writeBytes)
			munin.setFieldValue(fieldRead, readBytes)

def funcComposeNetIO():
	# Config
	munin.setOption('graph_title', 'Docker compose traffic')
	munin.setOption('graph_args', '--base 1000')
	munin.setOption('graph_vlabel', 'Bits in (-) / out (+) per second')

	# Fields
	projects = getComposeContainers()
	for project in projects:
		field = makeFieldName(project)
		fieldRx = '%s_rx' % (field)
		fieldTx = '%s_tx' % (field)

		munin.addField(fieldRx, {
			'label': truncate(project),
			'min': '0',
			'type': 'DERIVE',
			'graph': 'no',
		})
		munin.addField(fieldTx, {
			'label': truncate(project),
			'min': '0',
			'type': 'DERIVE',
			'negative': fieldRx,
		})

		# Values
		if munin.needValues:
			rxBits = 0
			txBits = 0
			for container in projects[project]:
				netio = getContainerNetIO(container)
				if netio == False:
					continue

				rxBits += netio['rxBits']
				txBits += netio['txBits']

			munin.setFieldValue(fieldRx, rxBits)
			munin.setFieldValue(fieldTx, txBits)

### Simple Munin ###
class SimpleMunin:
	def __init__(self):
		self.fields = collections.OrderedDict()
		self.options = {}
		self.functions = {}
		self.needValues = True if len(sys.argv) <= 1 else False

	def setOption(self, key, val):
		if val is not None:
			self.options[key] = val
		elif key in self.options:
			del self.options[key]

	def addField(self, id, config, val = None):
		self.fields[id] = {
			'config': config,
			'value': None
		}
		if val is not None:
			self.setFieldValue(id, val)

	def setFieldValue(self, id, val):
		self.fields[id]['value'] = val

	def registerFunc(self, name, func):
		self.functions[name] = func

	def run(self):
		pluginName = list(os.path.split(sys.argv[0]))[1]
		graphName = pluginName[pluginName.index('_')+1:]
		if graphName in self.functions:
			self.functions[graphName]()
		else:
			sys.exit(1)

		# Print config
		if len(sys.argv) > 1 and sys.argv[1] == 'config':
			for option in self.options:
				print '%s %s' % (option, self.options[option])

			for id in self.fields:
				field = self.fields[id]
				for key in field['config']:
					value = field['config'][key]
					print '%s.%s %s' % (id, key, value)
			sys.exit(0)

		# Print values
		for id in self.fields:
			if self.fields[id]['value'] is not None:
				# We want to print ints without and floats with decimals, because DERIVE exspects
				# integers.
				print ('%s.value ' + str(self.fields[id]['value'])) % (id)

### Main Program ###
munin = SimpleMunin()

# Default options
munin.setOption('graph_category', 'Docker')

# Define graphs
munin.registerFunc('cpu', funcCpu)
munin.registerFunc('memory', funcMemoryWithCache)
munin.registerFunc('memory_nocache', funcMemoryNoCache)
munin.registerFunc('blockio', funcBlockIO)
munin.registerFunc('netio', funcNetIO)

munin.registerFunc('compose_cpu', funcComposeCpu)
munin.registerFunc('compose_memory', funcComposeMemoryWithCache)
munin.registerFunc('compose_memory_nocache', funcComposeMemoryNoCache)
munin.registerFunc('compose_blockio', funcComposeBlockIO)
munin.registerFunc('compose_netio', funcComposeNetIO)

munin.registerFunc('volumes', funcVolumes)

munin.run()