fluent-plugin-mesosphere-filter 0.1.0 → 0.1.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODM4MTU1YmFjNGUyYWZjZTIzYTI1ZDUxZTE3MjZiZDY3ZWNhMWViYQ==
+    NTcyNGFiYTRlM2JmMTE4NWU3MTRlNjVhNzUzM2Y0YTYxMjUwODQ4Mg==
   data.tar.gz: !binary |-
-    YTZhNTVhZWRjZTE3ODMzNGYwMjM4YzU5ZGMyNDNjM2JmY2Q5ZWM3Mg==
+    NmRlODgyMDBhMWZlOTNhNTYyZmRjODA1OGI3YmJhMzUyYTkzMmExOQ==
 SHA512:
   metadata.gz: !binary |-
-    MTdkNTFiMjVkZTBkMDdhZDczZjc3ZGZhNzkzZGEyMjFlNTExYTU4ODliNjhk
-    ZGQ3NGU2NzdiYTZlZmY1NjYwM2MyOWY2ZDMwMTQ2ZDBjYzQyZGRmYzBkMjY2
-    MmQxZTM0YzdhMWNjNTY2Y2VkYzkwZTBhYzNjNzEzYzcyMjZjOGU=
+    MTcyNjE1NGQxMzBkMzFlOGVkMWQ3ZDI2MjI4Yjk3MDU2MWY5ZGYxNzdjMDlh
+    YTU0NzM4ZmVjMWJkNGVmMjNkODk2ZjJiMTIxYTFjNTA0MzBkNzk5ZmY4YWU3
+    ZjA5ZTM2N2YzNTZkMDcyZDc0YTMyNzEwYWZlZTY3ZmZlOTk3OGM=
   data.tar.gz: !binary |-
-    NTNkNTA4OTYwY2JkYzgwYjQyZWJkNmI1YmNmOTAwYTE2MDJjOTk3MTEyZmU3
-    ZmJjOTA1ZDgyZTdjMWY5MDI5YTExNDhmM2FiNTY4ZmMxODJhMGNmMmNlMDRi
-    MDgxNDY2MmE3MzQzNDA2ZTQ3NWIyYTBkZjA5NmMwYjU5YzM5MjY=
+    ZmY0ZDMxYjkxOTFlNGJhNzRlYTY5ODYxYmY4MjNhMTdhM2JiZjM4NGUzNWNl
+    MTBhMDUyMWRmOGY1YmFjZTcyYzQ1MzA3MDI5M2FmNzZhNjRkNjlmZWY4ZGNj
+    ZDc3YTA5NGU0ODRmNjdmNzhlMjZiZjU4NjIxOTM3YmFlYmY1NmY=

data/.gitignore

@@ -17,3 +17,4 @@ test/version_tmp
 tmp
 .idea/
 *.iml
+.DS_Store

data/README.md

@@ -1,3 +1,109 @@
-#MEsos Stuff
+#Mesosphere Fluentd Filter
 [![Code Climate](https://codeclimate.com/github/joshughes/fluent-plugin-mesosphere-filter/badges/gpa.svg)](https://codeclimate.com/github/joshughes/fluent-plugin-mesosphere-filter)
 [![Test Coverage](https://codeclimate.com/github/joshughes/fluent-plugin-mesosphere-filter/badges/coverage.svg)](https://codeclimate.com/github/joshughes/fluent-plugin-mesosphere-filter/coverage)
+[![Gem Version](https://badge.fury.io/rb/fluent-plugin-mesosphere-filter.svg)](https://badge.fury.io/rb/fluent-plugin-mesosphere-filter)
+[![Inline docs](http://inch-ci.org/github/joshughes/fluent-plugin-mesosphere-filter.svg?branch=master)](http://inch-ci.org/github/joshughes/fluent-plugin-mesosphere-filter)
+[![Dependency Status](https://www.versioneye.com/user/projects/5658d10aaef3b5003e000000/badge.svg?style=flat)](https://www.versioneye.com/user/projects/5658d10aaef3b5003e000000)
+
+Marathon, Chronos and Mesos combined can allow for teams to build a great solution for deploying and scaling containers. The issue is when you have a system like Kibana it can be hard to identify what container or task a log is coming from.
+
+This filter aims to solve that issue by inspecting containers to inject Mesosphere metatdata into the Fluentd event stream.
+
+##What gets injected?
+###Marathon
+
+|`key`|  Description  |
+|---|---|
+|`app`|  The application name in marathon  |
+|  `mesos_framework` |  marathon |
+| `mesos_task_id` | The unique Mesos task id running the docker container |
+
+###Chronos
+Chronos does not have the idea of an 'application'. Just jobs. We run a lot of jobs that relate to our applications so we use a naming scheme that allows us to extract the marathon application that is running the Chronos task.
+
+An example of a Chronos Job name is the following.
+
+`some-task-app2-11182015-1718-deployTasks-1-144786721`
+
+With the default regex in the plugin we extract the following data and inject it into the event stream.
+
+|`key`|  Description  | Value |
+|---|---|---|
+|`app`|  The application name running the task  | some-task-app2 |
+|  `mesos_framework` |  chronos | chronos |
+| `mesos_task_id` | The unique Mesos task id running the docker container | |
+| `chronos_task_type` | The task type our application is running. We run deployment and scheduled tasks. | deployTasks |
+
+##Configuration
+
+If your using the docker fluentd logging plugin your configuration should look something like this.
+
+```
+<source>
+  type forward
+  port 24224
+  bind 0.0.0.0
+</source>
+
+<filter docker.*>
+  type mesosphere-filter
+  cache_size 1000
+  cache_ttl 3600
+  merge_json_log true
+  cronos_task_regex (?<app>[a-z0-9]([-a-z0-9]*[a-z0-9]))-(?<date>[^-]+)-(?<time>[^-]+)-(?<task_type>[^-]+)-(?<run>[^-]+)-(?<epoc>[^-]+)
+</filter>
+
+<match docker.*>
+  type stdout
+</match>
+```
+
+|`key`|  Description  | Default |
+|---|---|---|
+|`cache_size`|  This plugin will cache information from the docker daemon. This configuration determine how large that cache is. | 1000 |
+|  `cache_ttl ` |  How long to keep items in the cache. | 3600 |
+| `merge_json_log ` | If your application logs in a valid json format, this will merge that into the event stream. | true |
+| `cronos_task_regex ` | If you don't provide a valid regex here then you will only get the mesos_task id from until you create a standard chronos job name that is parseable by a ruby regex. | **See example above** |
+
+
+##Example
+We have an application called `hello-world`. That application is deployed via marathon and has the following environment variables.
+
+|`key`|  value  |
+|---|---|
+| `MESOS_TASK_ID` | `hello-world.14b0596d-93ea-11e5-a134-124eefe69197`|
+| `MARATHON_APP_ID` | `/hello-world`|
+
+Like all great hello world applications. This docker container just execute:
+
+```bash
+echo '{"say":"Hello World"}'
+```
+
+Without this filter fluentd would process the docker log and output the following.
+
+```json
+{
+	"container_id": "ce327cb0de115f7dbfcd2c6055ba945436dada26035a62587b951332a028a530",
+	"container_name": "/some_random_meaningless_name",
+	"source": "stdout",
+	"log": "{\"say\":\"Hello World\"}\r"
+}
+```
+
+With the filter in place that log will become the following.
+
+```json
+{
+	"container_id": "ce327cb0de115f7dbfcd2c6055ba945436dada26035a62587b951332a028a530",
+	"container_name": "/some_random_meaningless_name",
+	"say": "Hello World",
+	"mesos_framework": "marathon",
+	"app": "hello-world",
+	"mesos_task_id": "unquie_task_id",
+	"source": "stdout",
+	"log": "{\"say\":\"Hello World\"}\r"
+}
+```
+
+So now in Kibana you can filter on many more fields and more easily track down issues when `hello-world` may be running in multiple containers that are associated with different Mesos tasks.

data/fluent-plugin-mesosphere-filter.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
   gem.name          = 'fluent-plugin-mesosphere-filter'
-  gem.version       = '0.1.0'
+  gem.version       = '0.1.1'
   gem.authors       = ['Joseph Hughes']
   gem.email         = ['jjhughes57@gmail.com']
   gem.description   = 'Filter plugin to add Mesosphere metadata'

data/lib/fluent/plugin/mesosphere.rb

@@ -16,21 +16,26 @@
 # limitations under the License.
 #
 module Fluent
+  # Parses Marathon and Chronos data from docker to make fluentd logs more
+  # useful.
   class MesosphereFilter < Fluent::Filter
     Fluent::Plugin.register_filter('mesosphere-filter', self)
 
     config_param :cache_size, :integer, default: 1000
     config_param :cache_ttl, :integer, default: 60 * 60
+    config_param :get_container_id_tag, :bool, default: true
+    config_param :container_id_attr, :string, default: 'container_id'
 
     config_param :merge_json_log, :bool, default: true
     config_param :cronos_task_regex,
                  :string,
-                 default: '(?<app>[a-z0-9]([-a-z0-9]*[a-z0-9]))-(?<date>[^-]+)-(?<time>[^-]+)-(?<task_type>[^-]+)-(?<run>[^-]+)-(?<epoc>[^-]+)'
+                 default: '(?<app>[a-z0-9]([-a-z0-9_]*[a-z0-9_]))-(?<date>[^-]+)-(?<time>[^-]+)-(?<task_type>[^-]+)-(?<run>[^-]+)-(?<epoc>[^-]+)'
 
     def initialize
       super
     end
 
+    # Get the configuration for the plugin
     def configure(conf)
       super
 
@@ -43,53 +48,137 @@ module Fluent
       @cache = LruRedux::TTL::ThreadSafeCache.new(@cache_size, @cache_ttl)
 
       @chronos_task_regex_compiled = Regexp.compile(@cronos_task_regex)
+
+      marathon_regex = '\/(?<app>[a-z0-9]([-a-z0-9_]*[a-z0-9_]))'
+      @marathon_app_regex_compiled = Regexp.compile(marathon_regex)
     end
 
+    # Gets the log event stream and moifies it. This is where the plugin hooks
+    # into the fluentd envent stream.
     def filter_stream(tag, es)
       new_es = MultiEventStream.new
+      container_id = ''
 
-      container_id = tag.split('.').last
-      mesos_data = @cache.getset(container_id) do
-        get_container_metadata(container_id)
-      end
+      container_id = get_container_id_from_tag(tag) if get_container_id_tag
 
       es.each do |time, record|
-        record = record.merge(mesos_data)
-        record = merge_json_log(record) if @merge_json_log
-        new_es.add(time, record)
+        container_id =
+          get_container_id_from_record(record) if container_id.empty?
+        next unless container_id
+        new_es.add(time, modify_record(record, get_mesos_data(container_id)))
       end
-
       new_es
     end
 
+    # Injects the meso framework data into the record and also merges
+    # the json log if that configuration is enabled.
+    #
+    # ==== Attributes:
+    # * +record+ - The log record being processed
+    # * +mesos_data+ - The mesos data retrived from the docker container
+    #
+    # ==== Returns:
+    # * A record hash that has mesos data and optinally log data added
+    def modify_record(record, mesos_data)
+      modified_record = record.merge(mesos_data)
+      modified_record = merge_json_log(modified_record) if @merge_json_log
+      modified_record
+    end
+
+    # Gets the mesos data about a container from the cache or calls the Docker
+    # api to retrieve the data about the container and store it in the cache.
+    #
+    # ==== Attributes:
+    # * +container_id+ - The container_id where the log record originated from.
+    # ==== Returns:
+    # * A hash of data that describes a mesos task
+    def get_mesos_data(container_id)
+      @cache.getset(container_id) do
+        get_container_metadata(container_id)
+      end
+    end
+
+    # Goes out to docker to get environment variables for a container.
+    # Then we parse the environment varibles looking for known Marathon
+    # and Chronos environment variables
+    #
+    # ==== Attributes:
+    # * +id+ - The id of the container to look at for mesosphere metadata.
+    # ==== Returns:
+    # * A hash that describes a mesos task gathered from the Docker API
     def get_container_metadata(id)
       task_data = {}
       container = Docker::Container.get(id)
       if container
         environment = container.json['Config']['Env']
         environment.each do |env|
+          # Chronos puts task_id in lowercase, and Marathon does it with
+          # uppercase
           if env =~ /MESOS_TASK_ID/i
             task_data['mesos_task_id'] = parse_env(env)
           elsif env.include? 'MARATHON_APP_ID'
+            match_data = parse_env(env).match(@marathon_app_regex_compiled)
             task_data['mesos_framework'] = 'marathon'
-            task_data['app'] = parse_env(env)
+            task_data['app'] = match_data['app'] if match_data
           elsif env.include? 'CHRONOS_JOB_NAME'
             match_data = parse_env(env).match(@chronos_task_regex_compiled)
             task_data['mesos_framework'] = 'chronos'
-            task_data['app'] = match_data['app']
-            task_data['chronos_task_type'] = match_data['task_type']
+            task_data['app'] = match_data['app'] if match_data
+            task_data['chronos_task_type'] = match_data['task_type'] if match_data
           end
         end
       end
       task_data
     end
 
+    # Gets the container id from the last element in the tag. If the user has
+    # configured container_id_attr the container id can be gathered from the
+    # record if it has been inserted there.
+    #
+    # ==== Attributes:
+    # * +tag+ - The tag of the log being processed
+    # ==== Returns:
+    # * A docker container id
+    def get_container_id_from_tag(tag)
+      tag.split('.').last
+    end
+
+    # If the user has configured container_id_attr the container id can be
+    # gathered from the record if it has been inserted there. If no container_id
+    # can be found, the record is not processed.
+    #
+    # ==== Attributes::
+    # * +record+ - The record that is being transformed by the filter
+    # ==== Returns:
+    # * A docker container id
+    def get_container_id_from_record(record)
+      record[@container_id_attr]
+    end
+
+    # Split the env var on = and return the value
+    # ==== Attributes:
+    # * +env+ - The docker environment variable to parse to get the value.
+    # ==== Examples
+    # # For the env value MARATHON_APP_ID the actual string value given to us
+    # # by docker is 'MARATHON_APP_ID=some-app'. We want to return 'some-app'.
+    # ==== Returns:
+    # * The value of an environment varaible
     def parse_env(env)
       env.split('=').last
     end
 
+    # Look at the log value and if it is valid json then we will parse the json
+    # and merge it into the log record.
+    # ==== Attributes:
+    # * +record+ - The record we are transforming in the fluentd event stream.
+    # ==== Examples
+    # # Docker captures stdout and passes it in the 'log' record attribute.
+    # # We try to discover is the value of 'log' is json, if it is then we
+    # # will parse the json and add the keys and values to the record.
+    # ==== Returns:
+    # * A record hash that has json log data merged into the record
     def merge_json_log(record)
-      if record.has_key?('log')
+      if record.key?('log')
         log = record['log'].strip
         if log[0].eql?('{') && log[-1].eql?('}')
           begin

data/test/containers/chronos_bad.json

@@ -0,0 +1,137 @@
+{
+  "AppArmorProfile": "",
+  "Args": [
+    " task",
+    "task"
+  ],
+  "Config": {
+    "AttachStderr": false,
+    "AttachStdin": false,
+    "AttachStdout": false,
+    "Cmd": [
+      " task",
+      "task"
+    ],
+    "CpuShares": 153,
+    "Cpuset": "",
+    "Domainname": "",
+    "Entrypoint": [
+      "/minimal"
+    ],
+    "Env": [
+      "mesos_task_id=ct:1448508194000:0:recurring-transaction3:task",
+      "CHRONOS_JOB_OWNER=chartreuse-team@itriagehealth.com",
+      "CHRONOS_JOB_NAME=foobarzasdf",
+      "HOST=ip-10-10-30-60.ec2.internal",
+      "CHRONOS_RESOURCE_MEM=1024.0",
+      "CHRONOS_RESOURCE_CPU=0.05",
+      "CHRONOS_RESOURCE_DISK=256.0",
+      "YEAR=2016",
+      "VAULT_HOSTS=https://dev-use1a-pr-01-vault-vault-0001.dev-utopia.com:8200,https://dev-use1b-pr-01-vault-vault-0001.dev-utopia.com:8200,https://dev-use1e-pr-01-vault-vault-0001.dev-utopia.com:8200",
+      "MESOS_SANDBOX=/mnt/mesos/sandbox",
+      "PORT=80"
+    ],
+    "ExposedPorts": {
+      "80/tcp": {}
+    },
+    "Hostname": "ip-10-10-30-60",
+    "Image": "docker-dev.itriagehealth.com/utopia/recurring-transaction2-task:564a03fd52f1800005000003",
+    "Labels": {},
+    "MacAddress": "",
+    "Memory": 1107296256,
+    "MemorySwap": -1,
+    "NetworkDisabled": false,
+    "OnBuild": null,
+    "OpenStdin": false,
+    "PortSpecs": null,
+    "StdinOnce": false,
+    "Tty": false,
+    "User": "",
+    "Volumes": null,
+    "WorkingDir": "/"
+  },
+  "Created": "2015-11-26T03:23:15.958740506Z",
+  "Driver": "overlay",
+  "ExecDriver": "native-0.2",
+  "ExecIDs": null,
+  "HostConfig": {
+    "Binds": [
+      "/data/mesos-slave/slaves/20151115-193554-4078832138-5050-1872-S2/docker/links/2e3e0f5c-ac02-40a0-804b-b4c7736935b5:/mnt/mesos/sandbox"
+    ],
+    "CapAdd": null,
+    "CapDrop": null,
+    "CgroupParent": "",
+    "ContainerIDFile": "",
+    "CpuShares": 153,
+    "CpusetCpus": "",
+    "Devices": [],
+    "Dns": null,
+    "DnsSearch": null,
+    "ExtraHosts": null,
+    "IpcMode": "",
+    "Links": null,
+    "LogConfig": {
+      "Config": null,
+      "Type": "json-file"
+    },
+    "LxcConf": [],
+    "Memory": 1107296256,
+    "MemorySwap": -1,
+    "NetworkMode": "host",
+    "PidMode": "",
+    "PortBindings": {},
+    "Privileged": false,
+    "PublishAllPorts": false,
+    "ReadonlyRootfs": false,
+    "RestartPolicy": {
+      "MaximumRetryCount": 0,
+      "Name": "no"
+    },
+    "SecurityOpt": null,
+    "Ulimits": null,
+    "VolumesFrom": null
+  },
+  "HostnamePath": "/data/docker/containers/8dac46bdb4c099f8a12c12e06b104e9ca86b839e241b386bf3ddb537c9923642/hostname",
+  "HostsPath": "/data/docker/containers/8dac46bdb4c099f8a12c12e06b104e9ca86b839e241b386bf3ddb537c9923642/hosts",
+  "Id": "foobar124",
+  "Image": "dc41b56ccebd1433c6be3a92b838cc64c8c5f7088237a3da08a380cf43d6d6ac",
+  "LogPath": "/data/docker/containers/8dac46bdb4c099f8a12c12e06b104e9ca86b839e241b386bf3ddb537c9923642/8dac46bdb4c099f8a12c12e06b104e9ca86b839e241b386bf3ddb537c9923642-json.log",
+  "MountLabel": "",
+  "Name": "/mesos-2e3e0f5c-ac02-40a0-804b-b4c7736935b5",
+  "NetworkSettings": {
+    "Bridge": "",
+    "Gateway": "",
+    "GlobalIPv6Address": "",
+    "GlobalIPv6PrefixLen": 0,
+    "IPAddress": "",
+    "IPPrefixLen": 0,
+    "IPv6Gateway": "",
+    "LinkLocalIPv6Address": "",
+    "LinkLocalIPv6PrefixLen": 0,
+    "MacAddress": "",
+    "PortMapping": null,
+    "Ports": null
+  },
+  "Path": "/minimal",
+  "ProcessLabel": "",
+  "ResolvConfPath": "/data/docker/containers/8dac46bdb4c099f8a12c12e06b104e9ca86b839e241b386bf3ddb537c9923642/resolv.conf",
+  "RestartCount": 0,
+  "State": {
+    "Dead": false,
+    "Error": "",
+    "ExitCode": 0,
+    "FinishedAt": "2015-11-26T03:23:16.090077843Z",
+    "OOMKilled": false,
+    "Paused": false,
+    "Pid": 0,
+    "Restarting": false,
+    "Running": false,
+    "StartedAt": "2015-11-26T03:23:16.01885868Z"
+  },
+  "Volumes": {
+    "/mnt/mesos/sandbox": "/data/mesos-slave/slaves/20151115-193554-4078832138-5050-1872-S2/frameworks/20150821-174742-1460275722-5050-14777-0001/executors/ct:1448508194000:0:recurring-transaction2:task/runs/2e3e0f5c-ac02-40a0-804b-b4c7736935b5"
+  },
+  "VolumesRW": {
+    "/mnt/mesos/sandbox": true
+  }
+}

data/test/containers/marathon.json

@@ -118,8 +118,8 @@
     "StdinOnce": false,
     "Env": [
       "FLUENTD_OPT=-vv",
-      "MESOS_TASK_ID=my-innovation-health-int-provider.14b0596d-93ea-11e5-a134-124eefe69197",
-      "MARATHON_APP_ID=/my-innovation-health-int-provider",
+      "MESOS_TASK_ID=hello-world.14b0596d-93ea-11e5-a134-124eefe69197",
+      "MARATHON_APP_ID=/hello-world",
       "FLUENTD_CONF=test.conf",
       "PATH=/home/ubuntu/ruby/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
       "FLUENTD_OPT="

data/test/containers/marathon2.json

@@ -0,0 +1,187 @@
+{
+  "Id": "somecontainer123",
+  "Created": "2015-11-26T06:57:56.560006039Z",
+  "Path": "/bin/sh",
+  "Args": [
+    "-c",
+    "exec fluentd -c /fluentd/etc/$FLUENTD_CONF -p /fluentd/plugins $FLUENTD_OPT"
+  ],
+  "State": {
+    "Status": "running",
+    "Running": true,
+    "Paused": false,
+    "Restarting": false,
+    "OOMKilled": false,
+    "Dead": false,
+    "Pid": 6563,
+    "ExitCode": 0,
+    "Error": "",
+    "StartedAt": "2015-11-26T07:00:45.707356204Z",
+    "FinishedAt": "2015-11-26T07:00:43.278299772Z"
+  },
+  "Image": "7cd5efd43c5097c8e6a9b6bdc050f887e0e1dee49a79b7eb920e2d741c36b3b5",
+  "ResolvConfPath": "/mnt/sda1/var/lib/docker/containers/110e3bd749e33e3b55bb55bec44a192457d722607afb1e6423e6a45a1c1e8b45/resolv.conf",
+  "HostnamePath": "/mnt/sda1/var/lib/docker/containers/110e3bd749e33e3b55bb55bec44a192457d722607afb1e6423e6a45a1c1e8b45/hostname",
+  "HostsPath": "/mnt/sda1/var/lib/docker/containers/110e3bd749e33e3b55bb55bec44a192457d722607afb1e6423e6a45a1c1e8b45/hosts",
+  "LogPath": "/mnt/sda1/var/lib/docker/containers/110e3bd749e33e3b55bb55bec44a192457d722607afb1e6423e6a45a1c1e8b45/110e3bd749e33e3b55bb55bec44a192457d722607afb1e6423e6a45a1c1e8b45-json.log",
+  "Name": "/fluentddockertest_fluentd_server_1",
+  "RestartCount": 0,
+  "Driver": "aufs",
+  "ExecDriver": "native-0.2",
+  "MountLabel": "",
+  "ProcessLabel": "",
+  "AppArmorProfile": "",
+  "ExecIDs": null,
+  "HostConfig": {
+    "Binds": [
+      "/Users/A658307/fluentd_docker_test/fluentd/etc:/fluentd/etc:rw",
+      "/Users/A658307/fluentd_docker_test/fluentd/logs:/fluentd/log:rw",
+      "/Users/A658307/fluentd_docker_test/fluentd/plugins:/fluentd/plugins:rw"
+    ],
+    "ContainerIDFile": "",
+    "LxcConf": null,
+    "Memory": 0,
+    "MemoryReservation": 0,
+    "MemorySwap": 0,
+    "KernelMemory": 0,
+    "CpuShares": 0,
+    "CpuPeriod": 0,
+    "CpusetCpus": "",
+    "CpusetMems": "",
+    "CpuQuota": 0,
+    "BlkioWeight": 0,
+    "OomKillDisable": false,
+    "MemorySwappiness": null,
+    "Privileged": false,
+    "PortBindings": {
+      "24224/tcp": [{
+        "HostIp": "",
+        "HostPort": "24224"
+      }]
+    },
+    "Links": null,
+    "PublishAllPorts": false,
+    "Dns": null,
+    "DnsOptions": null,
+    "DnsSearch": null,
+    "ExtraHosts": [],
+    "VolumesFrom": [],
+    "Devices": null,
+    "NetworkMode": "default",
+    "IpcMode": "",
+    "PidMode": "",
+    "UTSMode": "",
+    "CapAdd": null,
+    "CapDrop": null,
+    "GroupAdd": null,
+    "RestartPolicy": {
+      "Name": "",
+      "MaximumRetryCount": 0
+    },
+    "SecurityOpt": null,
+    "ReadonlyRootfs": false,
+    "Ulimits": null,
+    "LogConfig": {
+      "Type": "json-file",
+      "Config": {}
+    },
+    "CgroupParent": "",
+    "ConsoleSize": [
+      0,
+      0
+    ],
+    "VolumeDriver": ""
+  },
+  "GraphDriver": {
+    "Name": "aufs",
+    "Data": null
+  },
+  "Volumes": {
+    "/fluentd/etc": "/Users/A658307/fluentd_docker_test/fluentd/etc",
+    "/fluentd/log": "/Users/A658307/fluentd_docker_test/fluentd/logs",
+    "/fluentd/plugins": "/Users/A658307/fluentd_docker_test/fluentd/plugins"
+  },
+  "VolumesRW": {
+    "/fluentd/etc": true,
+    "/fluentd/log": true,
+    "/fluentd/plugins": true
+  },
+  "Config": {
+    "Hostname": "110e3bd749e3",
+    "Domainname": "",
+    "User": "ubuntu",
+    "AttachStdin": false,
+    "AttachStdout": false,
+    "AttachStderr": false,
+    "Tty": false,
+    "OpenStdin": false,
+    "StdinOnce": false,
+    "Env": [
+      "FLUENTD_OPT=-vv",
+      "MESOS_TASK_ID=hello-world.14b0596d-93ea-11e5-a134-124eefe69197",
+      "MARATHON_APP_ID=/hello-world",
+      "FLUENTD_CONF=test.conf",
+      "PATH=/home/ubuntu/ruby/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+      "FLUENTD_OPT="
+    ],
+    "Cmd": [
+      "/bin/sh",
+      "-c",
+      "exec fluentd -c /fluentd/etc/$FLUENTD_CONF -p /fluentd/plugins $FLUENTD_OPT"
+    ],
+    "Image": "fluent/fluentd:latest",
+    "Volumes": {
+      "/fluentd/etc": {},
+      "/fluentd/log": {},
+      "/fluentd/plugins": {}
+    },
+    "WorkingDir": "/home/ubuntu",
+    "Entrypoint": null,
+    "OnBuild": null,
+    "Labels": {
+      "Description": "Fluentd docker image",
+      "Vendor": "Fluent Organization",
+      "Version": "1.0",
+      "com.docker.compose.config-hash": "7a03ce1e88388255c166fa62dcad89a43d43034ce605265094cf9c9951dcc9f0",
+      "com.docker.compose.container-number": "1",
+      "com.docker.compose.oneoff": "False",
+      "com.docker.compose.project": "fluentddockertest",
+      "com.docker.compose.service": "fluentd_server",
+      "com.docker.compose.version": "1.5.1"
+    },
+    "MacAddress": "",
+    "NetworkDisabled": false,
+    "ExposedPorts": {
+      "24224/tcp": {}
+    },
+    "VolumeDriver": "",
+    "Memory": 0,
+    "MemorySwap": 0,
+    "CpuShares": 0,
+    "Cpuset": ""
+  },
+  "NetworkSettings": {
+    "Bridge": "",
+    "SandboxID": "f304aa3b0e20fe1e0edb5984aedd03b7d5df999ff5ff9bd3ef8f831923e5f96a",
+    "HairpinMode": false,
+    "LinkLocalIPv6Address": "",
+    "LinkLocalIPv6PrefixLen": 0,
+    "Ports": {
+      "24224/tcp": [{
+        "HostIp": "0.0.0.0",
+        "HostPort": "24224"
+      }]
+    },
+    "SandboxKey": "/var/run/docker/netns/f304aa3b0e20",
+    "SecondaryIPAddresses": null,
+    "SecondaryIPv6Addresses": null,
+    "EndpointID": "7c6889977686db7c2b2042798b021a03df61c4273dcfd84fb2a9e5830fcb71a9",
+    "Gateway": "172.17.0.1",
+    "GlobalIPv6Address": "",
+    "GlobalIPv6PrefixLen": 0,
+    "IPAddress": "172.17.0.2",
+    "IPPrefixLen": 16,
+    "IPv6Gateway": "",
+    "MacAddress": "02:42:ac:11:00:02"
+  }
+}

data/test/plugin/test_mesosphere.rb

@@ -21,6 +21,10 @@ class AmplifierFilterTest < Test::Unit::TestCase
     cache_size 2000
     cache_ttl 300
   ]
+  CONFIG3 = %[
+    get_container_id_tag false
+    container_id_attr container_id
+  ]
 
   def create_driver(conf = CONFIG, tag = 'test')
     Fluent::Test::FilterTestDriver.new(Fluent::MesosphereFilter, tag).configure(conf)
@@ -31,9 +35,9 @@ class AmplifierFilterTest < Test::Unit::TestCase
       .to_return(status: 200, body: file, headers: {})
   end
 
-  def setup_marathon_container
-    docker_api_url = 'http://tcp//example.com:5422/v1.16/containers/foobar123/json'
-    file = File.open('test/containers/marathon.json', 'rb')
+  def setup_marathon_container(container_id, file_name)
+    docker_api_url = "http://tcp//example.com:5422/v1.16/containers/#{container_id}/json"
+    file = File.open("test/containers/#{file_name}.json", 'rb')
     setup_docker_stub(file, docker_api_url)
   end
 
@@ -44,7 +48,7 @@ class AmplifierFilterTest < Test::Unit::TestCase
   end
 
   def test_marathon_filter
-    setup_marathon_container
+    setup_marathon_container('foobar123', 'marathon')
 
     d1 = create_driver(CONFIG, 'docker.foobar123')
     d1.run do
@@ -52,17 +56,17 @@ class AmplifierFilterTest < Test::Unit::TestCase
     end
     filtered = d1.filtered_as_array
 
-    task_id = 'my-innovation-health-int-provider.14b0596d-93ea-11e5-a134-124eefe69197'
+    task_id = 'hello-world.14b0596d-93ea-11e5-a134-124eefe69197'
 
     log_entry = filtered[0][2]
 
     assert_equal 'marathon', log_entry['mesos_framework']
-    assert_equal '/my-innovation-health-int-provider', log_entry['app']
+    assert_equal 'hello-world', log_entry['app']
     assert_equal task_id, log_entry['mesos_task_id']
   end
 
   def test_container_cache
-    setup_marathon_container
+    setup_marathon_container('foobar123', 'marathon')
 
     d1 = create_driver(CONFIG, 'docker.foobar123')
     d1.run do
@@ -77,7 +81,7 @@ class AmplifierFilterTest < Test::Unit::TestCase
   end
 
   def test_container_cache_expiration
-    setup_marathon_container
+    setup_marathon_container('foobar123', 'marathon')
 
     d1 = create_driver(CONFIG2, 'docker.foobar123')
     d1.run do
@@ -115,6 +119,26 @@ class AmplifierFilterTest < Test::Unit::TestCase
     assert_equal 'deployTasks', log_entry['chronos_task_type']
   end
 
+  def test_chronos_bad_match
+    docker_api_url = 'http://tcp//example.com:5422/v1.16/containers/foobar124/json'
+    file = File.open('test/containers/chronos_bad.json', 'rb')
+    setup_docker_stub(file, docker_api_url)
+
+    d1 = create_driver(CONFIG, 'docker.foobar124')
+    d1.run do
+      d1.filter('log' => 'Hello World 1')
+    end
+    filtered = d1.filtered_as_array
+
+    task_id = 'ct:1448508194000:0:recurring-transaction3:task'
+    log_entry = filtered[0][2]
+
+    assert_equal 'chronos', log_entry['mesos_framework']
+    assert_equal task_id, log_entry['mesos_task_id']
+    refute log_entry['app']
+    refute log_entry['chronos_task_type']
+  end
+
   def test_merge_json
     setup_chronos_container
 
@@ -143,4 +167,21 @@ class AmplifierFilterTest < Test::Unit::TestCase
     assert_equal bad_json1, filtered[0][2]['log']
     assert_equal bad_json2, filtered[1][2]['log']
   end
+
+  def test_container_id_from_record
+    setup_marathon_container('somecontainer123', 'marathon2')
+
+    d1 = create_driver(CONFIG3, 'docker')
+    d1.run do
+      d1.filter('log' => 'hello_world', 'container_id' => 'somecontainer123')
+    end
+    filtered = d1.filtered_as_array
+
+    task_id = 'hello-world.14b0596d-93ea-11e5-a134-124eefe69197'
+    log_entry = filtered[0][2]
+
+    assert_equal 'marathon', log_entry['mesos_framework']
+    assert_equal 'hello-world', log_entry['app']
+    assert_equal task_id, log_entry['mesos_task_id']
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-mesosphere-filter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Joseph Hughes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-26 00:00:00.000000000 Z
+date: 2015-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -195,7 +195,9 @@ files:
 - fluent-plugin-mesosphere-filter.gemspec
 - lib/fluent/plugin/mesosphere.rb
 - test/containers/chronos.json
+- test/containers/chronos_bad.json
 - test/containers/marathon.json
+- test/containers/marathon2.json
 - test/helper.rb
 - test/plugin/test_mesosphere.rb
 homepage: https://github.com/joshughes/fluent-plugin-mesosphere-filter
@@ -224,6 +226,8 @@ specification_version: 4
 summary: Filter plugin to add Mesosphere metadata to fluentd from Chronos and Marathon
 test_files:
 - test/containers/chronos.json
+- test/containers/chronos_bad.json
 - test/containers/marathon.json
+- test/containers/marathon2.json
 - test/helper.rb
 - test/plugin/test_mesosphere.rb