Metrics Console Exporter + Add last_updated_timestamp to metrics

README.md

@@ -39,6 +39,8 @@ pip install -e ./ext/opentelemetry-ext-{integration}
 
 ## Quick Start
 
+### Tracing
+
 ```python
 from opentelemetry import trace
 from opentelemetry.context import Context
@@ -57,6 +59,34 @@ with tracer.start_span('foo'):
             print(Context)
 ```
 
+### Metrics
+
+```python
+from opentelemetry import metrics
+from opentelemetry.sdk.metrics import Counter, Meter
+from opentelemetry.sdk.metrics.export import ConsoleMetricsExporter
+
+metrics.set_preferred_meter_implementation(lambda T: Meter())
+meter = metrics.meter()
+exporter = ConsoleMetricsExporter()
+
+counter = meter.create_metric(
+    "available memory",
+    "available memory",
+    "bytes",
+    int,
+    Counter,
+    ("environment",),
+)
+
+label_values = ("staging",)
+counter_handle = counter.get_handle(label_values)
+counter_handle.add(100)
+
+exporter.export([(counter, label_values)])
+exporter.shutdown()
+```
+
 See the [API
 documentation](https://open-telemetry.github.io/opentelemetry-python/) for more
 detail, and the

opentelemetry-sdk/src/opentelemetry/sdk/metrics/__init__.py

@@ -16,6 +16,7 @@
 from typing import Sequence, Tuple, Type
 
 from opentelemetry import metrics as metrics_api
+from opentelemetry.sdk.util import time_ns
 
 logger = logging.getLogger(__name__)
 
@@ -31,6 +32,7 @@ def __init__(
         self.value_type = value_type
         self.enabled = enabled
         self.monotonic = monotonic
+        self.last_update_timestamp = time_ns()
 
     def _validate_update(self, value: metrics_api.ValueT):
         if not self.enabled:
@@ -42,13 +44,19 @@ def _validate_update(self, value: metrics_api.ValueT):
             return False
         return True
 
+    def __repr__(self):
+        return '{}(data="{}", last_update_timestamp={})'.format(
+            type(self).__name__, self.data, self.last_update_timestamp
+        )
+
 
 class CounterHandle(metrics_api.CounterHandle, BaseHandle):
     def update(self, value: metrics_api.ValueT) -> None:
         if self._validate_update(value):
             if self.monotonic and value < 0:
                 logger.warning("Monotonic counter cannot descend.")
                 return
+            self.last_update_timestamp = time_ns()
             self.data += value
 
     def add(self, value: metrics_api.ValueT) -> None:
@@ -62,6 +70,7 @@ def update(self, value: metrics_api.ValueT) -> None:
             if self.monotonic and value < self.data:
                 logger.warning("Monotonic gauge cannot descend.")
                 return
+            self.last_update_timestamp = time_ns()
             self.data = value
 
     def set(self, value: metrics_api.ValueT) -> None:
@@ -75,6 +84,7 @@ def update(self, value: metrics_api.ValueT) -> None:
             if self.monotonic and value < 0:
                 logger.warning("Monotonic measure cannot accept negatives.")
                 return
+            self.last_update_timestamp = time_ns()
             # TODO: record
 
     def record(self, value: metrics_api.ValueT) -> None:
@@ -116,6 +126,11 @@ def get_handle(self, label_values: Sequence[str]) -> BaseHandle:
         self.handles[label_values] = handle
         return handle
 
+    def __repr__(self):
+        return '{}(name="{}", description={})'.format(
+            type(self).__name__, self.name, self.description
+        )
+
 
 class Counter(Metric):
     """See `opentelemetry.metrics.Counter`.

opentelemetry-sdk/src/opentelemetry/sdk/metrics/export/__init__.py

@@ -0,0 +1,77 @@
+# Copyright 2019, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from enum import Enum
+from typing import Sequence, Tuple
+
+from .. import Metric
+
+
+class MetricsExportResult(Enum):
+    SUCCESS = 0
+    FAILED_RETRYABLE = 1
+    FAILED_NOT_RETRYABLE = 2
+
+
+class MetricsExporter:
+    """Interface for exporting metrics.
+
+    Interface to be implemented by services that want to export recorded
+    metrics in its own format.
+    """
+
+    def export(
+        self, metric_tuples: Sequence[Tuple[Metric, Sequence[str]]]
+    ) -> "MetricsExportResult":
+        """Exports a batch of telemetry data.
+
+        Args:
+            metric_tuples: A sequence of metric pairs. A metric pair consists
+                of a `Metric` and a sequence of strings. The sequence of
+                strings will be used to get the corresponding `MetricHandle`
+                from the `Metric` to import.
+
+        Returns:
+            The result of the export
+        """
+
+    def shutdown(self) -> None:
+        """Shuts down the exporter.
+
+        Called when the SDK is shut down.
+        """
+
+
+class ConsoleMetricsExporter(MetricsExporter):
+    """Implementation of :class:`MetricsExporter` that prints metric handles
+    to the console.
+
+    This class can be used for diagnostic purposes. It prints the exported
+    metric handles to the console STDOUT.
+    """
+
+    def export(
+        self, metric_tuples: Sequence[Tuple[Metric, Sequence[str]]]
+    ) -> "MetricsExportResult":
+        for metric_tuple in metric_tuples:
+            handle = metric_tuple[0].get_handle(metric_tuple[1])
+            print(
+                '{}(data="{}", label_values="{}", metric_data={})'.format(
+                    type(self).__name__,
+                    metric_tuple[0],
+                    metric_tuple[1],
+                    handle,
+                )
+            )
+        return MetricsExportResult.SUCCESS