{
    "info": {
        "author": "troylar",
        "author_email": "troylars@amazon.com",
        "bugtrack_url": null,
        "classifiers": [
            "Development Status :: 5 - Production/Stable",
            "License :: OSI Approved :: Apache Software License",
            "Topic :: Utilities"
        ],
        "description": "# FluentMetrics\n## **IMPORTANT: When using unique stream IDs, you have the potential to create a large number of metrics. Please make sure to review the [current AWS CloudWatch Custom Metrics pricing]( https://aws.amazon.com/cloudwatch/pricing/) before proceeding.**\n## Overview\n`FluentMetrics` is an easy-to-use Python module that makes logging CloudWatch custom metrics a breeze. The goal is to provide a framework for logging detailed metrics with a minimal footprint. When you look at your code logic, you want to see your actual code logic, not line after line of metrics logging.  `FluentMetrics` lets you maximize your metrics footprint while minimizing your metrics code footprint.\n## Installation\nYou can install directly from PyPI:\n\n```sh\npip install cloudwatch-fluent-metrics\n```\n## 'Fluent' . . . what is that?\nFluent describes an easy-to-read programming style. The goal of fluent development is to make code easier to read and reduce the amount of code required to build objects. It's easier to take a look a comparison between fluent and non-fluent style.\n#### Non-Fluent Example\n```sh\ng = Game()\nf = Frame(Name='Tom')\nf.add_score(7)\nf.add_score(3)\ng.add_frame(f)\nf = Frame(Name='Tom')\nf.add_strike()\ng.add_frame(f)\n```\n#### Non-Fluent Example with Constructor\n```sh\ng = Game()\ng.add_frame(Frame(Name='Tom', Score1=7, Score2=3)\ng.add_frame(Frame(Name='Tom', Score1=10)\n```\n#### Fluent Example\n```sh\ng = Game()\ng.add_frame(Frame().with_name('Tom').score(3).spare())\ng.add_frame(Frame().with_name('Tom').strike())\n```\nWhile the difference may seem to be nitpicking, a frame is really just a constructed object. In the first example, we're taking up three lines of code to create the object--there's nothing wrong with that. However, in the second example, we're using constructors. This is slightly more readable, but there's a great deal of logic bulked up in our constructor. In the third example, we're using fluent-style code as it starts at creating the frame and *fluently* continues until it's created the entire frame in a single line. And more importantly, *it's readable.* We're not just creating an object with a massive constructor or spending several lines of code just to create a single object.\n## Terminology Quickstart\n#### Namespaces\nEvery metric needs to live in a namespace. Since you are logging your own custom metrics, you need to provide a custom namespace for your metric. Click [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) for a list of the standard AWS namespaces.\n*Example*:\nIn this example, we're creating a simple `FluentMetric` in a namespace called `Performance`. This means that every time we log a metric with `m`, we will automatically log it to the `Performance` namespace.\n```sh\nfrom fluentmetrics import FluentMetric\nm = FluentMetric().with_namespace('Performance')\n```\n#### Metric Names\nThe metric name is the thing you are actually logging. Each value that you log must be tied to a metric name. When you log a custom metric with a new metric name, the name will automatically be created if it doesn't already exist. Click [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) to see existing metrics that can help you define names for your custom metrics.\n*Example*:\nIn this example, we're logging two metrics called `StartupTime` and `StuffTime` to the `Performance` namespace (we only needed to define the namespace once).\n```sh\nm = FluentMetric().with_namespace('Performance')\nm.log(MetricName='StartupTime', Value=27, Unit='Seconds')\ndo_stuff()\nm.log(MetricName='StuffTime', Value=12000, Unit='Milliseconds')\n```\n#### Values\nObviously we need to log a value with each metric. This needs to be a number since we convert this value to a `float` before sending to CloudWatch. \n**IMPORTANT**: When logging multiple values for the same custom metric within a minute, CloudWatch aggregates an average over a minute. Click [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#publishingDataPoints) for more details.\n#### Storage Resolution\nThe PutMetricData function now accepts an optional StorageResolution parameter. Set this parameter to 1 to publish high-resolution metrics; omit it (or set it to 60) to publish at standard 1-minute resolution.\n*Example*:\nIn this example, we're logging metric at one-second resolution:\n```sh\nm = FluentMetric().with_namespace('Application/MyApp')\n                  .with_storage_resolution(1)\nm.log(MetricName='Transactions/Sec', Value=trans_count, Unit='Count/Sec')\n```sh\n#### Dimensions\nA dimension defines how you want to slice and dice the metric. These are simply name-value pairs and you can define up to 10 per metric. Click [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#usingDimensions) for more details on using dimensions.\n**IMPORTANT:** When you define multiple dimensions, CloudMetrics attaches all of those dimensions to the metric as a single combined dimension set--think of them as an aggregate primary key. For example, if you log a metric with the dimensions `os = 'linux'` and `flavor='ubunutu'` you will only be able to aggregate by **both** `os` and `flavor`. You **cannot** aggregate only by just `os` or just `flavor`. `FluentMetrics` solves this problem by automatically logging three metrics--one for `os`, one for `flavor` and then one for the combied dimensions, giving you maximum flexibility.\n*Example*:\nIn this example, we're logging boot/restart time metrics. When this code executes, we will end up with 6 metrics:\n* `BootTime` and `RestartTime` for `os`\n* `BootTime` and `RestartTime` for `instance-id`\n* `BootTime` and `RestartTime` for 'os` and `instance-id`\n```sh\nm = FluentMetric().with_namespace('Performance/EC2') \\\n                  .with_dimension('os', 'linux'). \\\n                  .with_dimension('instance-id', 'i-123456')\nboot_time = start_instance()\nm.log(MetricName='BootTime', Value=boot_time, Unit='Milliseconds')\nrestart_time = restart_instance()\nm.log(MetricName='RestartTime', Value=restart_time, Unit='Milliseconds')\n```\n#### Units\nCloudWatch has built-in logic to provide meaning to the metric values. We're not just logging a value--we're logging a value of some unit. By defining the unit type, CloudWatch will know how to properly present, aggregate and compare that value with other values. For example, if you submit a value with unit `Milliseconds`, then it can properly aggregate it up to seconds, minutes or hours. This is a list of the most current valid list of units. A more up-to-date list should be available [here](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html) under the **Unit** section,.\n```sh\n\"Seconds\"|\"Microseconds\"|\"Milliseconds\"|\"Bytes\"|\"Kilobytes\"|\"Megabytes\"|\n\"Gigabytes\"|\"Terabytes\"|\"Bits\"|\"Kilobits\"|\"Megabits\"|\"Gigabits\"|\"Terabits\"|\n\"Percent\"|\"Count\"|\"Bytes/Second\"|\"Kilobytes/Second\"|\"Megabytes/Second\"|\n\"Gigabytes/Second\"|\"Terabytes/Second\"|\"Bits/Second\"|\"Kilobits/Second\"|\n\"Megabits/Second\"|\"Gigabits/Second\"|\"Terabits/Second\"|\"Count/Second\"|\"None\"\n```\n##### Unit Shortcut Methods\nIf you don't want to type out the individual unit name, there are shortcut methods for each unit.\n\n```sh\nm = FluentMetric().with_namespace('Performance/EC2') \\\n                  .with_dimension('os', 'linux'). \\\n                  .with_dimension('instance-id', 'i-123456')\nm.seconds(MetricName='CompletionInSeconds', Value='1000')\nm.microseconds(MetricName='CompletionInMicroseconds', Value='1000')\nm.milliseconds(MetricName='CompletionInMilliseconds', Value='1000')\nm.bytes(MetricName='SizeInBytes', Value='1000')\nm.kb(MetricName='SizeInKb', Value='1000')\nm.mb(MetricName='SizeInMb', Value='1000')\nm.gb(MetricName='SizeInGb', Value='1000')\nm.tb(MetricName='SizeInTb', Value='1000')\nm.bits(MetricName='SizeInBits', Value='1000')\nm.kbits(MetricName='SizeInKilobits', Value='1000')\nm.mbits(MetricName='SizeInMegabits', Value='1000')\nm.gbits(MetricName='SizeInGigabits', Value='1000')\nm.tbits(MetricName='SizeInTerabits', Value='1000')\nm.pct(MetricName='Percent', Value='20')\nm.count(MetricName='ItemCount', Value='20')\nm.bsec(MetricName='BandwidthBytesPerSecond', Value='1000')\nm.kbsec(MetricName='BandwidthKilobytesPerSecond', Value='1000')\nm.mbsec(MetricName='BandwidthMegabytesPerSecond', Value='1000')\nm.gbsec(MetricName='BandwidthGigabytesPerSecond', Value='1000')\nm.tbsec(MetricName='BandwidthTerabytesPerSecond', Value='1000')\nm.bitsec(MetricName='BandwidthBitsPerSecond', Value='1000')\nm.kbitsec(MetricName='BandwidthKilobitsPerSecond', Value='1000')\nm.mbitsec(MetricName='BandwidthMegabitsPerSecond', Value='1000')\nm.gbitsec(MetricName='BandwidthGigabitsPerSecond', Value='1000')\nm.tbitsec(MetricName='BandwidthTerabitsPerSecond', Value='1000')\nm.countsec(MetricName='ItemCountsPerSecond', Value='1000')\n```\n#### Timers\nOne of the most common uses of logging is measuring performance. FluentMetrics allows you to activate multiple built-in timers by name and log the elapsed time in a single line of code. **NOTE:** The elapsed time value is automatically stored as unit `Milliseconds`.\n*Example*:\nIn this example, we're starting timers `workflow` and `job1` at the same time. Timers start as soon as you create them and never stop running. When you call `elapsed`, `FluentMetrics` will log the number of elapsed milliseconds with the `MetricName`.\n```sh\nm = FluentMetric()\nm.with_timer('workflow').with_timer('job1')\ndo_job1()\nm.elapsed(MetricName='Job1CompletionTime', TimerName='job1')\nm.with_timer('job2')\ndo_job2()\nm.elapsed(MetricName='Job2CompletionTime', TimerName='job2')\nfinish_workflow()\nm.elapsed(MetricName='WorkflowCompletionTime', TimerName='workflow')\n```\n#### Metric Stream ID\nA key feature of `FluentMetrics` is the metric stream ID. This ID will be added as a dimension and logged with every metric. The benefit of this dimension is to provide a distinct stream of metrics for an end-to-end operation. When you create a new instance of `FluentMetric`, you can either pass in your own value or `FluentMetrics` will generate a GUID. In CloudWatch, you can then see all of the metrics for a particular stream ID in chronological order. A metric stream can be a job, or a server or any way that you want to unique group a contiguous stream of metrics.\n*Example*:\nIn this example, we'll have two metrics in the `Performance` namespace, each with metric stream ID of `abc-123`. We can then go to CloudWatch and filter by that stream ID to see the entire operation performance at a glance.\n```sh\nm = FluentMetric().with_namespace('Performance').with_stream_id('abc-123')\nm.log(MetricName='StartupTime', Value=100, Unit='Seconds')\ndo_work()\nm.log(MetricName='WorkCompleted', Value=1000, Unit='Milliseconds')\n```\n## Use Case Quickstart\n#### #1: Least Amount of Code Required to Log a Metric\nThis is the minimal amount of work you need to log--create a `FluentMetric` with a namespace, then log a value.\n**Result**: This code will log a single value `100` for `ActiveServerCount` in the `Stats` namespace.\n```sh\nfrom fluentmetrics import FluentMetric\nm = FluentMetric().with_namespace('Stats')\nm.log(MetricName='ActiveServerCount', Value='100', Unit='Count')\n```\n#### #2: Logging Multiple Metrics to the Same Namespace\nIf you are logging multiple metrics to the same namespace, this is a great use case for `FluentMetrics`. You only need to create one instance of `FluentMetric` and specify a different metric name when you call `log`. \n**Result**: This code will log a single value `100` for `ActiveServerCount` in the `Stats` namespace.\n```sh\nfrom fluentmetrics import FluentMetric   \nm = FluentMetric().with_namespace('Stats')\nm.log(MetricName='ActiveServerCount', Value='10', Unit='Count') \\\n .log(MetricName='StoppedServerCount', Value='20', Unit='Count') \\\n .log(MetricName='ActiveLinuxCount', Value='50', Unit='Count') \\\n .log(MetricName='ActiveWindowsCount', Value='50', Unit='Count')\n````\n#### #3: Logging Counts\nIn the previous example, we logged a metric and identified the unit `Count`. Instead of specifying the unit, you can specify the type of object\n**Result**: This code will log a single value `100` for `ActiveServerCount` in the `Stats` namespace.\n\n```sh\nfrom fluentmetrics import FluentMetric\nm = FluentMetric().with_namespace('Stats')\nm.count(MetricName='ActiveServerCount', Value='10')\n```\n\n#### BufferedFluentMetric\nNormally, with FluentMetric, metrics are sent immediately when `log` is called (or `count`, `milliseconds`, etc). This\ncan result in a lot of `put_metric_data` calls to CloudWatch that are not full. When you use `BufferedFluentMetric` \ninstead of `FluentMetric`, it waits until it has the maximum (20) metrics before calling `put_metric_data`. This optimizes\ntraffic to cloudwatch.\n\nIn general, `BufferedFluentMetric` behaves identically to `FluentMetric`, except that now it is possible to \"forget\" to\nsend some metrics. The `BufferedFluentMetric.flush()` method pushes out all metrics immediately (clears the buffer). It\nis often best to do this at the end of a request (or some other obviously bounded interval).\n\nHere is an example of how it works in Flask:\n\n```python\nfrom flask import g\nfrom fluentmetrics import BufferedFluentMetric\n\n@app.before_request\ndef start_request():\n\tg.metrics = BufferedFluentMetric()\n\tg.metrics.with_namespace('MyApp')\n\tg.metrics.with_timer('RequestLatency')\n\n@app.after_request\ndef end_request(response):\n\tdef error_counter(hundred):\n\t\tif response.status_code / 100 == hundred:\n\t\t\treturn 1\n\t\telse:\n\t\t\treturn 0\n\n\tg.metrics.count(MetricName='4xxError', Value=error_counter(400))\n\tg.metrics.count(MetricName='5xxError', Value=error_counter(500))\n\tg.metrics.count(MetricName='Availability', Value=(1 - error_counter(500)))\n\tg.metrics.elapsed(MetricName='RequestLatency', TimerName='RequestLatency')\n\n\t# Finally, ensure that all metrics end up in CloudWatch before this request finally ends.\n\tg.metrics.flush()\n```\n\n## License\n\nThis library is licensed under the Apache 2.0 License.",
        "description_content_type": "text/markdown",
        "docs_url": null,
        "download_url": "https://github.com/awslabs/cloudwatch-fluent-metrics/cloudwatch-fluent-metrics-v0.1.tgz",
        "downloads": {
            "last_day": -1,
            "last_month": -1,
            "last_week": -1
        },
        "home_page": "https://github.com/awslabs/cloudwatch-fluent-metrics",
        "keywords": "metrics,logging,aws,cloudwatch",
        "license": "Apache-2.0",
        "maintainer": "",
        "maintainer_email": "",
        "name": "cloudwatch-fluent-metrics",
        "package_url": "https://pypi.org/project/cloudwatch-fluent-metrics/",
        "platform": "",
        "project_url": "https://pypi.org/project/cloudwatch-fluent-metrics/",
        "project_urls": {
            "Download": "https://github.com/awslabs/cloudwatch-fluent-metrics/cloudwatch-fluent-metrics-v0.1.tgz",
            "Homepage": "https://github.com/awslabs/cloudwatch-fluent-metrics"
        },
        "release_url": "https://pypi.org/project/cloudwatch-fluent-metrics/0.5.3/",
        "requires_dist": null,
        "requires_python": "",
        "summary": "AWS CloudWatch Fluent Metrics",
        "version": "0.5.3"
    },
    "last_serial": 5796983,
    "releases": {
        "0.1.4": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "b42d05df70b82c854df5c272871bbf00",
                    "sha256": "4e01f30ece7ce7914e4774d9d7671e53bacb5ecd7eb3ece00688d344b1fcb0ec"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.1.4.tar.gz",
                "has_sig": false,
                "md5_digest": "b42d05df70b82c854df5c272871bbf00",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 6106,
                "upload_time": "2017-04-01T13:11:40",
                "url": "https://files.pythonhosted.org/packages/2c/e1/0929474b0077f592656b0ced8d66226dae01baa8e84f8cce902773239a45/cloudwatch-fluent-metrics-0.1.4.tar.gz"
            }
        ],
        "0.1.5": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "53a2f8860a59063a49026e87af59896c",
                    "sha256": "2e6d27c8d974e89996f619ceb4ff4adb8ef16d48cef4b39d4b1ac423b19bb0cb"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.1.5.tar.gz",
                "has_sig": false,
                "md5_digest": "53a2f8860a59063a49026e87af59896c",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 8257,
                "upload_time": "2017-04-01T13:24:11",
                "url": "https://files.pythonhosted.org/packages/de/60/43cf0ad9656e52a01f8e845b1f000e28db9cc2371b34e9aadf682232bc0f/cloudwatch-fluent-metrics-0.1.5.tar.gz"
            }
        ],
        "0.1.6": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "6729a176f80046714ab3717cd2624ff0",
                    "sha256": "a402eb9bcc77d128329ebfff078c0db490f375d725985a6e0cc5874f4074a665"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.1.6.tar.gz",
                "has_sig": false,
                "md5_digest": "6729a176f80046714ab3717cd2624ff0",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 8249,
                "upload_time": "2017-04-01T13:30:06",
                "url": "https://files.pythonhosted.org/packages/82/c4/06b2a34e93d01ba3d5ab2de45d62d651e3b45782968f756aee0d128eadd1/cloudwatch-fluent-metrics-0.1.6.tar.gz"
            }
        ],
        "0.1.7": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "a848de0eb2eb840867073f5f48848122",
                    "sha256": "b6459759ac9ef247e9f074c01db432a5167d692a629ea560c673c1f2176a9412"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.1.7.tar.gz",
                "has_sig": false,
                "md5_digest": "a848de0eb2eb840867073f5f48848122",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 8222,
                "upload_time": "2017-04-01T13:46:06",
                "url": "https://files.pythonhosted.org/packages/66/83/e8094ea08205b67e088416007a19081e1106b7bbc40383d56dd7050534c7/cloudwatch-fluent-metrics-0.1.7.tar.gz"
            }
        ],
        "0.1.8": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "7bd455296eb801b6d0ce87667c1bec58",
                    "sha256": "22511f60805a109ba077415f1c5b08bc1198f37451daf87ad7c9d40b08d1f6ce"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.1.8.tar.gz",
                "has_sig": false,
                "md5_digest": "7bd455296eb801b6d0ce87667c1bec58",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 8228,
                "upload_time": "2017-05-24T14:13:58",
                "url": "https://files.pythonhosted.org/packages/c0/61/8a90b3dc3cb3ca944735ea004faa7bc0cfe6f4931e527a018bb8b41ee713/cloudwatch-fluent-metrics-0.1.8.tar.gz"
            }
        ],
        "0.1.9": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "e3ac795c38c38fdbf44a05be03636907",
                    "sha256": "ff2cb206a393b6e847a6f73850b8f869b82bbecd8a9ef6e90656794a6c6aae9e"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.1.9.tar.gz",
                "has_sig": false,
                "md5_digest": "e3ac795c38c38fdbf44a05be03636907",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 8228,
                "upload_time": "2017-06-09T15:23:43",
                "url": "https://files.pythonhosted.org/packages/35/dc/30f8735ff2d4d59fda5eaa4d4b1b7d7fe6899cf67d329c00a1625fe5181c/cloudwatch-fluent-metrics-0.1.9.tar.gz"
            }
        ],
        "0.2.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "d29e2a0b85d63119fe82abfae8d456ac",
                    "sha256": "0c59ddeb2b68776ed82463dd70b05115c9cd517e7b221505344999c0b45c1446"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.2.0.tar.gz",
                "has_sig": false,
                "md5_digest": "d29e2a0b85d63119fe82abfae8d456ac",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 8230,
                "upload_time": "2017-06-09T16:28:45",
                "url": "https://files.pythonhosted.org/packages/27/19/15aad81c0039f360faa8992e11329bb4d540a320c8baaf26845ca32e606c/cloudwatch-fluent-metrics-0.2.0.tar.gz"
            }
        ],
        "0.3.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "260ec658f732a5ce52d5267f899b75c2",
                    "sha256": "48f698eece432339e24b7cc52306543aa3a1ef181d071ef95f9ffbe8d86fa45c"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.3.0.tar.gz",
                "has_sig": false,
                "md5_digest": "260ec658f732a5ce52d5267f899b75c2",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 10736,
                "upload_time": "2017-11-15T13:44:53",
                "url": "https://files.pythonhosted.org/packages/83/33/8035f22b473ff7a5a24c8279b68ef345973a8c19cc55125f30220a66a995/cloudwatch-fluent-metrics-0.3.0.tar.gz"
            }
        ],
        "0.5.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "f1bb088937997b52b75b73b4f33f06d4",
                    "sha256": "bef60e390e51e6c1c46eb71ef1c569f6dfe72ac61a65169d31f7b464c3c2bf53"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.5.1.tar.gz",
                "has_sig": false,
                "md5_digest": "f1bb088937997b52b75b73b4f33f06d4",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 14781,
                "upload_time": "2019-08-31T20:37:42",
                "url": "https://files.pythonhosted.org/packages/68/7e/399fea0bcb25957c2aebf75454bfea075a0809c900f446dc8e3fa588f0ef/cloudwatch-fluent-metrics-0.5.1.tar.gz"
            }
        ],
        "0.5.2": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "823a73684013764f136f3cacbd9d6dec",
                    "sha256": "bbce6973539e1a84401e1ea806ba5031c97263f57c4c8f358ade0cde761e79a9"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.5.2.tar.gz",
                "has_sig": false,
                "md5_digest": "823a73684013764f136f3cacbd9d6dec",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 14815,
                "upload_time": "2019-08-31T20:58:05",
                "url": "https://files.pythonhosted.org/packages/9b/ea/bdfec055657bc1089df8589263acf0b28cf6f0dfb814641e7a663655a580/cloudwatch-fluent-metrics-0.5.2.tar.gz"
            }
        ],
        "0.5.3": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "456d8224ad707ab21ba591e0bd9cbe18",
                    "sha256": "761063fdea3045d0103978f4fe17dc0a60fa9f986e2a4e34f861720be477ed2b"
                },
                "downloads": -1,
                "filename": "cloudwatch-fluent-metrics-0.5.3.tar.gz",
                "has_sig": false,
                "md5_digest": "456d8224ad707ab21ba591e0bd9cbe18",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 14888,
                "upload_time": "2019-09-07T18:42:30",
                "url": "https://files.pythonhosted.org/packages/4f/0c/c37dbceec42ded11068746d44b94f52e0d13be826df0d0aefdf81f040eca/cloudwatch-fluent-metrics-0.5.3.tar.gz"
            }
        ]
    },
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "md5": "456d8224ad707ab21ba591e0bd9cbe18",
                "sha256": "761063fdea3045d0103978f4fe17dc0a60fa9f986e2a4e34f861720be477ed2b"
            },
            "downloads": -1,
            "filename": "cloudwatch-fluent-metrics-0.5.3.tar.gz",
            "has_sig": false,
            "md5_digest": "456d8224ad707ab21ba591e0bd9cbe18",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": null,
            "size": 14888,
            "upload_time": "2019-09-07T18:42:30",
            "url": "https://files.pythonhosted.org/packages/4f/0c/c37dbceec42ded11068746d44b94f52e0d13be826df0d0aefdf81f040eca/cloudwatch-fluent-metrics-0.5.3.tar.gz"
        }
    ]
}