async def test_send_custom_schema_event_as_list( self, resource_group, eventgrid_topic, eventgrid_topic_primary_key, eventgrid_topic_endpoint): akc_credential = AzureKeyCredential(eventgrid_topic_primary_key) client = EventGridPublisherClient(eventgrid_topic_endpoint, akc_credential) custom_event1 = CustomEvent({ "customSubject": "sample", "customEventType": "sample.event", "customDataVersion": "2.0", "customId": "1234", "customEventTime": dt.datetime.now(UTC()).isoformat(), "customData": "sample data" }) custom_event2 = CustomEvent({ "customSubject": "sample2", "customEventType": "sample.event", "customDataVersion": "2.0", "customId": "12345", "customEventTime": dt.datetime.now(UTC()).isoformat(), "customData": "sample data 2" }) await client.send([custom_event1, custom_event2])
def publish(): # [START publish_eg_event_dict] credential = AzureKeyCredential(topic_key) client = EventGridPublisherClient(endpoint, credential) event0 = { "eventType": "Contoso.Items.ItemReceived", "data": { "itemSku": "Contoso Item SKU #1" }, "subject": "Door1", "dataVersion": "2.0", "id": "randomuuid11", "eventTime": datetime.now(UTC()) } event1 = { "eventType": "Contoso.Items.ItemReceived", "data": { "itemSku": "Contoso Item SKU #2" }, "subject": "Door1", "dataVersion": "2.0", "id": "randomuuid12", "eventTime": datetime.now(UTC()) } client.send([event0, event1])
def publish_event(): # authenticate client credential = AzureKeyCredential(key) client = EventGridPublisherClient(endpoint, credential) custom_schema_event = { "customSubject": "sample", "customEventType": "sample.event", "customDataVersion": "2.0", "customId": uuid.uuid4(), "customEventTime": dt.datetime.now(UTC()).isoformat(), "customData": "sample data" } # publish events for _ in range(3): event_list = [] # list of events to publish # create events and append to list for j in range(randint(1, 3)): event_list.append(custom_schema_event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))
def __init__(self, subject, event_type, **kwargs): # type: (str, str, Any) -> None kwargs.setdefault('id', uuid.uuid4()) kwargs.setdefault('subject', subject) kwargs.setdefault("event_type", event_type) kwargs.setdefault('event_time', dt.datetime.now(UTC()).isoformat()) kwargs.setdefault('data', None) super(EventGridEvent, self).__init__(**kwargs)
def __init__(self, source, type, **kwargs): # type: (str, str, Any) -> None kwargs.setdefault('id', uuid.uuid4()) kwargs.setdefault("source", source) kwargs.setdefault("type", type) kwargs.setdefault("time", dt.datetime.now(UTC()).isoformat()) kwargs.setdefault("specversion", "1.0") super(CloudEvent, self).__init__(**kwargs)
async def test_send_custom_schema_event_as_list(self, variables, eventgrid_custom_event_topic_endpoint): client = self.create_eg_publisher_client(eventgrid_custom_event_topic_endpoint) custom_event1 = { "customSubject": "sample", "customEventType": "sample.event", "customDataVersion": "2.0", "customId": "1234", "customEventTime": dt.datetime.now(UTC()).isoformat(), "customData": "sample data" } custom_event2 = { "customSubject": "sample2", "customEventType": "sample.event", "customDataVersion": "2.0", "customId": "12345", "customEventTime": dt.datetime.now(UTC()).isoformat(), "customData": "sample data 2" } await client.send([custom_event1, custom_event2])
def __init__(self, subject, event_type, data, data_version, **kwargs): # type: (str, str, object, str, Any) -> None kwargs.setdefault("id", uuid.uuid4()) kwargs.setdefault("subject", subject) kwargs.setdefault("event_type", event_type) kwargs.setdefault("event_time", dt.datetime.now(UTC()).isoformat()) kwargs.setdefault("data", data) kwargs.setdefault("data_version", data_version) super(EventGridEvent, self).__init__(**kwargs)
async def test_send_signature_credential(self, resource_group, eventgrid_topic, eventgrid_topic_primary_key, eventgrid_topic_endpoint): expiration_date_utc = dt.datetime.now(UTC()) + timedelta(hours=1) signature = generate_shared_access_signature(eventgrid_topic_endpoint, eventgrid_topic_primary_key, expiration_date_utc) credential = EventGridSharedAccessSignatureCredential(signature) client = EventGridPublisherClient(eventgrid_topic_endpoint, credential) eg_event = EventGridEvent( subject="sample", data={"sample": "eventgridevent"}, event_type="Sample.EventGrid.Event", data_version="2.0" ) await client.send(eg_event)
def test_send_signature_credential(self, variables, eventgrid_topic_key, eventgrid_topic_endpoint): expiration_date_utc = dt.datetime.now(UTC()) + timedelta(hours=1) signature = generate_sas(eventgrid_topic_endpoint, eventgrid_topic_key, expiration_date_utc) credential = AzureSasCredential(signature) client = EventGridPublisherClient(eventgrid_topic_endpoint, credential) eg_event = EventGridEvent(subject="sample", data={"sample": "eventgridevent"}, event_type="Sample.EventGrid.Event", data_version="2.0") client.send(eg_event)
def __init__(self, source, type, **kwargs): # pylint: disable=redefined-builtin # type: (str, str, Any) -> None self.source = source self.type = type self.specversion = kwargs.pop("specversion", "1.0") self.id = kwargs.pop("id", str(uuid.uuid4())) self.time = kwargs.pop("time", dt.datetime.now(UTC()).isoformat()) self.data = kwargs.pop("data", None) self.datacontenttype = kwargs.pop("datacontenttype", None) self.dataschema = kwargs.pop("dataschema", None) self.subject = kwargs.pop("subject", None) self.extensions = {} self.extensions.update(dict(kwargs.pop('extensions', {})))
def publish_event(): # authenticate client credential = AzureKeyCredential(key) client = EventGridPublisherClient(endpoint, credential) # [START publish_custom_schema] custom_schema_event = { "customSubject": "sample", "customEventType": "sample.event", "customDataVersion": "2.0", "customId": uuid.uuid4(), "customEventTime": dt.datetime.now(UTC()).isoformat(), "customData": "sample data" } client.send(custom_schema_event)
def test_query_start_and_end_time(): credential = _credential() client = LogsQueryClient(credential) query = "AppRequests | take 5" end_time = datetime.now(UTC()) start_time = end_time - timedelta(days=3) def callback(request): dic = json.loads(request.http_request.body) assert dic.get('timespan') is not None client.query_workspace(os.environ['LOG_WORKSPACE_ID'], query, timespan=(start_time, end_time), raw_request_hook=callback)
def test_query_duration_and_start_time(): credential = _credential() client = LogsQueryClient(credential) query = "AppRequests | take 5" end_time = datetime.now(UTC()) start_time = end_time - timedelta(days=3) duration = timedelta(days=3) def callback(request): dic = json.loads(request.http_request.body) assert '/PT259200.0S' in dic.get('timespan') client.query(os.environ['LOG_WORKSPACE_ID'], query, timespan=(start_time, duration), raw_request_hook=callback)
def __init__(self, source, type, **kwargs): # pylint: disable=redefined-builtin # type: (str, str, Any) -> None self.source = source self.type = type self.specversion = kwargs.pop("specversion", "1.0") self.id = kwargs.pop("id", str(uuid.uuid4())) self.time = kwargs.pop("time", dt.datetime.now(UTC()).isoformat()) self.data = kwargs.pop("data", None) self.datacontenttype = kwargs.pop("datacontenttype", None) self.dataschema = kwargs.pop("dataschema", None) self.subject = kwargs.pop("subject", None) self.data_base64 = kwargs.pop("data_base64", None) self.extensions = {} self.extensions.update(dict(kwargs.pop('extensions', {}))) if self.data is not None and self.data_base64 is not None: raise ValueError("data and data_base64 cannot be provided at the same time.\ Use data_base64 only if you are sending bytes, and use data otherwise.")
def test_query_duration_and_end_time(): credential = _credential() client = LogsQueryClient(credential) query = "AppRequests | take 5" end_time = datetime.now(UTC()) duration = 'P3D' def callback(request): dic = json.loads(request.http_request.body) assert 'P3D/' in dic.get('timespan') client.query(os.environ['LOG_WORKSPACE_ID'], query, duration=duration, end_time=end_time, raw_request_hook=callback)
def test_duration_to_iso8601(): d1 = timedelta(days=1) d2 = timedelta(weeks=1) d3 = timedelta(weeks=3, days=4) d4 = timedelta(seconds=10) d5 = timedelta(microseconds=1000) d6 = timedelta(milliseconds=100000) d7 = timedelta(hours=24, days=1) assert construct_iso8601(timespan=d1) == 'PT86400.0S' assert construct_iso8601(timespan=d2) == 'PT604800.0S' assert construct_iso8601(timespan=d3) == 'PT2160000.0S' assert construct_iso8601(timespan=d4) == 'PT10.0S' assert construct_iso8601(timespan=d5) == 'PT0.001S' assert construct_iso8601(timespan=d5) == 'PT0.001S' assert construct_iso8601(timespan=d7) == 'PT172800.0S' with pytest.raises(ValueError, match="timespan must be a timedelta or a tuple."): construct_iso8601(timespan=(datetime.now(UTC())))
def test_generate_sas_adds_https_if_not_exists(): expiration_date_utc = dt.datetime.now(UTC()) + timedelta(hours=1) http_endpoint = "topic.eventgrid.endpoint" signature = generate_sas(http_endpoint, "eventgrid_topic_primary_key", expiration_date_utc) assert signature.startswith("r=https")
def test_generate_sas_adds_https_appends_api_events(): expiration_date_utc = dt.datetime.now(UTC()) + timedelta(hours=1) http_endpoint = "https://topic.eventgrid.endpoint" signature = generate_sas(http_endpoint, "eventgrid_topic_primary_key", expiration_date_utc) assert "%2Fapi%2Fevents" in signature
from azure.monitor.query import LogsQueryClient from azure.identity import ClientSecretCredential credential = ClientSecretCredential( client_id=os.environ['AZURE_CLIENT_ID'], client_secret=os.environ['AZURE_CLIENT_SECRET'], tenant_id=os.environ['AZURE_TENANT_ID']) client = LogsQueryClient(credential) # Response time trend # request duration over the last 12 hours. query = """AppRequests | summarize avgRequestDuration=avg(DurationMs) by bin(TimeGenerated, 10m), _ResourceId""" end_time = datetime.now(UTC()) # returns LogsQueryResults response = client.query(os.environ['LOG_WORKSPACE_ID'], query, duration='PT1H', end_time=end_time) if not response.tables: print("No results for the query") #response.tables is a LogsQueryResultTable for table in response.tables: for col in table.columns: #LogsQueryResultColumn print(col.name + "/" + col.type + " | ", end="") print("\n")
def test_generate_sas_fails_with_http(): expiration_date_utc = dt.datetime.now(UTC()) + timedelta(hours=1) http_endpoint = "http://topic.eventgrid.endpoint" with pytest.raises(ValueError): signature = generate_sas(http_endpoint, "eventgrid_topic_primary_key", expiration_date_utc)
def _to_outgoing_amqp_message(self): message_header = None ttl_set = False if self.header: message_header = uamqp.message.MessageHeader() message_header.delivery_count = self.header.delivery_count message_header.time_to_live = self.header.time_to_live message_header.first_acquirer = self.header.first_acquirer message_header.durable = self.header.durable message_header.priority = self.header.priority if self.header.time_to_live and self.header.time_to_live != MAX_DURATION_VALUE: ttl_set = True creation_time_from_ttl = int( time.mktime(datetime.now(UTC()).timetuple())) absolute_expiry_time_from_ttl = int( min(MAX_ABSOLUTE_EXPIRY_TIME, creation_time_from_ttl + self.header.time_to_live)) message_properties = None if self.properties: creation_time = None absolute_expiry_time = None if ttl_set: creation_time = creation_time_from_ttl absolute_expiry_time = absolute_expiry_time_from_ttl else: if self.properties.creation_time: creation_time = int(self.properties.creation_time) if self.properties.absolute_expiry_time: absolute_expiry_time = int( self.properties.absolute_expiry_time) message_properties = uamqp.message.MessageProperties( message_id=self.properties.message_id, user_id=self.properties.user_id, to=self.properties.to, subject=self.properties.subject, reply_to=self.properties.reply_to, correlation_id=self.properties.correlation_id, content_type=self.properties.content_type, content_encoding=self.properties.content_encoding, creation_time=creation_time, absolute_expiry_time=absolute_expiry_time, group_id=self.properties.group_id, group_sequence=self.properties.group_sequence, reply_to_group_id=self.properties.reply_to_group_id, encoding=self._encoding) elif ttl_set: message_properties = uamqp.message.MessageProperties( creation_time=creation_time_from_ttl if ttl_set else None, absolute_expiry_time=absolute_expiry_time_from_ttl if ttl_set else None, ) amqp_body = self._message._body # pylint: disable=protected-access if isinstance(amqp_body, uamqp.message.DataBody): amqp_body_type = uamqp.MessageBodyType.Data amqp_body = list(amqp_body.data) elif isinstance(amqp_body, uamqp.message.SequenceBody): amqp_body_type = uamqp.MessageBodyType.Sequence amqp_body = list(amqp_body.data) else: # amqp_body is type of uamqp.message.ValueBody amqp_body_type = uamqp.MessageBodyType.Value amqp_body = amqp_body.data return uamqp.message.Message( body=amqp_body, body_type=amqp_body_type, header=message_header, properties=message_properties, application_properties=self.application_properties, annotations=self.annotations, delivery_annotations=self.delivery_annotations, footer=self.footer)
def test_from_json(): json_str = '{"id": "de0fd76c-4ef4-4dfb-ab3a-8f24a307e033", "subject": "https://egtest.dev/cloudcustomevent", "data": {"team": "event grid squad"}, "event_type": "Azure.Sdk.Sample", "event_time": "2020-08-07T02:06:08.11969Z", "data_version": "1.0"}' event = EventGridEvent.from_json(json_str) assert event.data == {"team": "event grid squad"} assert event.event_time == datetime.datetime(2020, 8, 7, 2, 6, 8, 119690, UTC())
from azure.core.credentials import AzureKeyCredential from azure.eventgrid import EventGridPublisherClient, CustomEvent key = os.environ["CUSTOM_SCHEMA_ACCESS_KEY"] topic_hostname = os.environ["CUSTOM_SCHEMA_TOPIC_HOSTNAME"] # authenticate client credential = AzureKeyCredential(key) client = EventGridPublisherClient(topic_hostname, credential) custom_schema_event = { "customSubject": "sample", "customEventType": "sample.event", "customDataVersion": "2.0", "customId": uuid.uuid4(), "customEventTime": dt.datetime.now(UTC()).isoformat(), "customData": "sample data" } # publish events while True: event_list = [] # list of events to publish # create events and append to list for j in range(randint(1, 3)): event = CustomEvent(custom_schema_event) event_list.append(event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list)))
def utc_from_timestamp(timestamp): return datetime.datetime.fromtimestamp(timestamp, tz=UTC())
def utc_now(): return datetime.datetime.now(UTC())