def entry_from_resource(resource, client, loggers):
"""Detect correct entry type from resource and instantiate.
:type resource: dict
:param resource: One entry resource from API response.
:type client: :class:`~google.cloud.logging.client.Client`
:param client: Client that owns the log entry.
:type loggers: dict
:param loggers:
A mapping of logger fullnames -> loggers. If the logger
that owns the entry is not in ``loggers``, the entry
will have a newly-created logger.
:rtype: :class:`~google.cloud.logging.entries._BaseEntry`
:returns: The entry instance, constructed via the resource
"""
if "textPayload" in resource:
return TextEntry.from_api_repr(resource, client, loggers)
if "jsonPayload" in resource:
return StructEntry.from_api_repr(resource, client, loggers)
if "protoPayload" in resource:
return ProtobufEntry.from_api_repr(resource, client, loggers)
return LogEntry.from_api_repr(resource, client, loggers)
def entry_from_resource(resource, client, loggers):
"""Detect correct entry type from resource and instantiate.
:type resource: dict
:param resource: One entry resource from API response.
:type client: :class:`~google.cloud.logging.client.Client`
:param client: Client that owns the log entry.
:type loggers: dict
:param loggers:
A mapping of logger fullnames -> loggers. If the logger
that owns the entry is not in ``loggers``, the entry
will have a newly-created logger.
:rtype: :class:`~google.cloud.logging.entries._BaseEntry`
:returns: The entry instance, constructed via the resource
"""
if 'textPayload' in resource:
return TextEntry.from_api_repr(resource, client, loggers)
elif 'jsonPayload' in resource:
return StructEntry.from_api_repr(resource, client, loggers)
elif 'protoPayload' in resource:
return ProtobufEntry.from_api_repr(resource, client, loggers)
raise ValueError('Cannot parse log entry resource.')
def test_log_text_explicit(self):
import datetime
from google.cloud.logging.resource import Resource
from google.cloud.logging.entries import TextEntry
TEXT = 'This is the entry text'
LABELS = {'foo': 'bar', 'baz': 'qux'}
IID = 'IID'
SEVERITY = 'CRITICAL'
METHOD = 'POST'
URI = 'https://api.example.com/endpoint'
STATUS = '500'
REQUEST = {
'requestMethod': METHOD,
'requestUrl': URI,
'status': STATUS,
}
TIMESTAMP = datetime.datetime(2016, 12, 31, 0, 1, 2, 999999)
RESOURCE = Resource(
type='gae_app',
labels={
'module_id': 'default',
'version_id': 'test'
}
)
TRACE = '12345678-1234-5678-1234-567812345678'
SPANID = '000000000000004a'
ENTRY = TextEntry(
payload=TEXT,
labels=LABELS,
insert_id=IID,
severity=SEVERITY,
http_request=REQUEST,
timestamp=TIMESTAMP,
resource=RESOURCE,
trace=TRACE,
span_id=SPANID,
trace_sampled=True,
)
client = _Client(project=self.PROJECT, connection=_make_credentials())
logger = _Logger()
batch = self._make_one(logger, client=client)
batch.log_text(
TEXT,
labels=LABELS,
insert_id=IID,
severity=SEVERITY,
http_request=REQUEST,
timestamp=TIMESTAMP,
resource=RESOURCE,
trace=TRACE,
span_id=SPANID,
trace_sampled=True,
)
self.assertEqual(batch.entries, [ENTRY])
def log_text(self, text, **kw):
"""Add a text entry to be logged during :meth:`commit`.
:type text: str
:param text: the text entry
:type kw: dict
:param kw: (optional) additional keyword arguments for the entry.
See :class:`~google.cloud.logging.entries.LogEntry`.
"""
self.entries.append(TextEntry(payload=text, **kw))
def test_log_text_explicit(self):
import datetime
from google.cloud.logging.resource import Resource
from google.cloud.logging.entries import TextEntry
TEXT = "This is the entry text"
LABELS = {"foo": "bar", "baz": "qux"}
IID = "IID"
SEVERITY = "CRITICAL"
METHOD = "POST"
URI = "https://api.example.com/endpoint"
STATUS = "500"
REQUEST = {
"requestMethod": METHOD,
"requestUrl": URI,
"status": STATUS
}
TIMESTAMP = datetime.datetime(2016, 12, 31, 0, 1, 2, 999999)
RESOURCE = Resource(type="gae_app",
labels={
"module_id": "default",
"version_id": "test"
})
TRACE = "12345678-1234-5678-1234-567812345678"
SPANID = "000000000000004a"
ENTRY = TextEntry(
payload=TEXT,
labels=LABELS,
insert_id=IID,
severity=SEVERITY,
http_request=REQUEST,
timestamp=TIMESTAMP,
resource=RESOURCE,
trace=TRACE,
span_id=SPANID,
trace_sampled=True,
)
client = _Client(project=self.PROJECT, connection=_make_credentials())
logger = _Logger()
batch = self._make_one(logger, client=client)
batch.log_text(
TEXT,
labels=LABELS,
insert_id=IID,
severity=SEVERITY,
http_request=REQUEST,
timestamp=TIMESTAMP,
resource=RESOURCE,
trace=TRACE,
span_id=SPANID,
trace_sampled=True,
)
self.assertEqual(batch.entries, [ENTRY])
def test_log_text_defaults(self):
from google.cloud.logging.entries import _GLOBAL_RESOURCE
from google.cloud.logging.entries import TextEntry
TEXT = "This is the entry text"
ENTRY = TextEntry(payload=TEXT, resource=_GLOBAL_RESOURCE)
client = _Client(project=self.PROJECT, connection=_make_credentials())
logger = _Logger()
batch = self._make_one(logger, client=client)
batch.log_text(TEXT)
self.assertEqual(batch.entries, [ENTRY])
def test_context_mgr_failure(self):
import datetime
from google.protobuf.struct_pb2 import Struct
from google.protobuf.struct_pb2 import Value
from google.cloud.logging.entries import TextEntry
from google.cloud.logging.entries import StructEntry
from google.cloud.logging.entries import ProtobufEntry
TEXT = "This is the entry text"
STRUCT = {"message": TEXT, "weather": "partly cloudy"}
LABELS = {"foo": "bar", "baz": "qux"}
IID = "IID"
SEVERITY = "CRITICAL"
METHOD = "POST"
URI = "https://api.example.com/endpoint"
STATUS = "500"
REQUEST = {
"requestMethod": METHOD,
"requestUrl": URI,
"status": STATUS
}
TIMESTAMP = datetime.datetime(2016, 12, 31, 0, 1, 2, 999999)
message = Struct(fields={"foo": Value(bool_value=True)})
client = _Client(project=self.PROJECT)
api = client.logging_api = _DummyLoggingAPI()
logger = _Logger()
UNSENT = [
TextEntry(payload=TEXT, insert_id=IID, timestamp=TIMESTAMP),
StructEntry(payload=STRUCT, severity=SEVERITY),
ProtobufEntry(payload=message, labels=LABELS,
http_request=REQUEST),
]
batch = self._make_one(logger, client=client)
try:
with batch as other:
other.log_text(TEXT, insert_id=IID, timestamp=TIMESTAMP)
other.log_struct(STRUCT, severity=SEVERITY)
other.log_proto(message, labels=LABELS, http_request=REQUEST)
raise _Bugout()
except _Bugout:
pass
self.assertEqual(list(batch.entries), UNSENT)
self.assertIsNone(api._write_entries_called_with)
def test_context_mgr_failure(self):
import datetime
from google.protobuf.struct_pb2 import Struct
from google.protobuf.struct_pb2 import Value
from google.cloud.logging.entries import TextEntry
from google.cloud.logging.entries import StructEntry
from google.cloud.logging.entries import ProtobufEntry
TEXT = 'This is the entry text'
STRUCT = {'message': TEXT, 'weather': 'partly cloudy'}
LABELS = {'foo': 'bar', 'baz': 'qux'}
IID = 'IID'
SEVERITY = 'CRITICAL'
METHOD = 'POST'
URI = 'https://api.example.com/endpoint'
STATUS = '500'
REQUEST = {
'requestMethod': METHOD,
'requestUrl': URI,
'status': STATUS,
}
TIMESTAMP = datetime.datetime(2016, 12, 31, 0, 1, 2, 999999)
message = Struct(fields={'foo': Value(bool_value=True)})
client = _Client(project=self.PROJECT)
api = client.logging_api = _DummyLoggingAPI()
logger = _Logger()
UNSENT = [
TextEntry(payload=TEXT, insert_id=IID, timestamp=TIMESTAMP),
StructEntry(payload=STRUCT, severity=SEVERITY),
ProtobufEntry(
payload=message, labels=LABELS, http_request=REQUEST),
]
batch = self._make_one(logger, client=client)
try:
with batch as other:
other.log_text(TEXT, insert_id=IID, timestamp=TIMESTAMP)
other.log_struct(STRUCT, severity=SEVERITY)
other.log_proto(message, labels=LABELS, http_request=REQUEST)
raise _Bugout()
except _Bugout:
pass
self.assertEqual(list(batch.entries), UNSENT)
self.assertIsNone(api._write_entries_called_with)
def _entry_from_resource(self, resource, loggers):
"""Detect correct entry type from resource and instantiate.
:type resource: dict
:param resource: one entry resource from API response
:type loggers: dict or None
:param loggers: A mapping of logger fullnames -> loggers. If not
passed, the entry will have a newly-created logger.
:rtype: One of:
:class:`google.cloud.logging.entries.TextEntry`,
:class:`google.cloud.logging.entries.StructEntry`,
:class:`google.cloud.logging.entries.ProtobufEntry`
:returns: the entry instance, constructed via the resource
"""
if 'textPayload' in resource:
return TextEntry.from_api_repr(resource, self, loggers)
elif 'jsonPayload' in resource:
return StructEntry.from_api_repr(resource, self, loggers)
elif 'protoPayload' in resource:
return ProtobufEntry.from_api_repr(resource, self, loggers)
raise ValueError('Cannot parse log entry resource')
def _entry_from_resource(self, resource, loggers):
"""Detect correct entry type from resource and instantiate.
:type resource: dict
:param resource: one entry resource from API response
:type loggers: dict or None
:param loggers: A mapping of logger fullnames -> loggers. If not
passed, the entry will have a newly-created logger.
:rtype: One of:
:class:`google.cloud.logging.entries.TextEntry`,
:class:`google.cloud.logging.entries.StructEntry`,
:class:`google.cloud.logging.entries.ProtobufEntry`
:returns: the entry instance, constructed via the resource
"""
if 'textPayload' in resource:
return TextEntry.from_api_repr(resource, self, loggers)
elif 'jsonPayload' in resource:
return StructEntry.from_api_repr(resource, self, loggers)
elif 'protoPayload' in resource:
return ProtobufEntry.from_api_repr(resource, self, loggers)
raise ValueError('Cannot parse log entry resource')
