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_send_event_grid_event_data_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) eg_event1 = EventGridEvent(subject="sample", data="eventgridevent", event_type="Sample.EventGrid.Event", data_version="2.0") eg_event2 = EventGridEvent(subject="sample2", data="eventgridevent2", event_type="Sample.EventGrid.Event", data_version="2.0") client.send([eg_event1, eg_event2])
def test_send_cloud_event_data_with_extensions(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) cloud_event = CloudEvent( source = "http://samplesource.dev", data = "cloudevent", type="Sample.Cloud.Event", extensions={ 'reasoncode':204, 'extension':'hello' } ) client.send([cloud_event]) internal = _cloud_event_to_generated(cloud_event).serialize() assert 'reasoncode' in internal assert 'extension' in internal assert internal['reasoncode'] == 204
def test_send_event_grid_event_dict_data_dict(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) eg_event = { "subject": "sample", "data": { "key1": "Sample.EventGrid.Event" }, "eventType": "Sample.EventGrid.Event", "dataVersion": "2.0", "id": uuid.uuid4(), "eventTime": datetime.now() } client.send(eg_event)
def test_send_event_grid_event_dict_data_bytes(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) eg_event = { "subject": "sample", "data": b"eventgridevent", "eventType": "Sample.EventGrid.Event", "dataVersion": "2.0", "id": uuid.uuid4(), "eventTime": datetime.now() } with pytest.raises(TypeError, match="Data in EventGridEvent cannot be bytes*"): client.send(eg_event)
def test_send_cloud_event_data_str(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) attributes = { "type": "com.example.sampletype1", "source": "https://example.com/event-producer", } data = "hello world" def callback(request): req = json.loads(request.http_request.body) assert req[0].get("data_base64") is None assert req[0].get("data") is not None cloud_event = CloudEvent(attributes, data) client.send(cloud_event, raw_request_hook=callback)
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 = { "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" } client.send([custom_event1, custom_event2])
def main(): # Read configuration information config_dict = loadcfg() cfg_event_grid_topic_key = config_dict['eventgridtopickey'] cfg_event_grid_topic_endpoint = config_dict['eventgridtopicendpoint'] event = EventGridEvent(data={ "make": "Audi", "model": "Q5" }, subject="myapp/vehicles/cars", event_type="recordInserted", data_version="1.0") credential = AzureKeyCredential(cfg_event_grid_topic_key) print('Sending event to Event Grid Topic ...') client = EventGridPublisherClient(cfg_event_grid_topic_endpoint, credential) # Send event client.send(event) print('Sent')
def test_send_cloud_event_data_dict(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) attributes = { "type": "com.example.sampletype1", "source": "https://example.com/event-producer", } data = {"message": "Hello World!"} cloud_event = CloudEvent(attributes, data) def callback(request): req = json.loads(request.http_request.body) assert req[0].get("data") is not None assert isinstance(req[0], dict) assert req[0].get("type") == "com.example.sampletype1" assert req[0].get("source") == "https://example.com/event-producer" client.send(cloud_event, raw_request_hook=callback)
class EventGrid: def __init__(self): self.subscriptions = {} self.client = EventGridPublisherClient(event_grid_endpoint, AzureKeyCredential(event_grid_key)) def publish(self, topic, message=''): try: print(f'event_grid.publish({topic}, {message})') event = EventGridEvent(data=message, subject=topic, event_type="mobil-e-hub", data_version="1.0") self.client.send(event) except Error as err: print(err) def receive(self, event): # Decompose event topic = event['subject'] message = event['data'] entity, id, *args = topic.split('/') topic = { 'entity': entity, 'id': id, 'args': args, 'rest': '/'.join(args), 'string': topic } print(f'> (opt) {topic["string"]}: {message}') # Call matching subscriptions for pattern, handlers in self.subscriptions.items(): if match_topic(pattern, topic['string']): for handler in handlers: handler(topic, message) def subscribe(self, pattern, handler): if pattern in self.subscriptions: self.subscriptions[pattern].append(handler) else: self.subscriptions[pattern] = [handler] def unsubscribe(self, pattern, handler): if pattern in self.subscriptions: self.subscriptions[pattern].remove(handler) if len(self.subscriptions[pattern]) == 0: del self.subscriptions[pattern]
""" FILE: sample_publish_events_using_cloud_events_1.0_schema.py DESCRIPTION: These samples demonstrate creating a list of CloudEvents and sending then as a list. USAGE: python sample_publish_events_using_cloud_events_1.0_schema.py Set the environment variables with your own values before running the sample: 1) CLOUD_ACCESS_KEY - The access key of your eventgrid account. 2) CLOUD_TOPIC_HOSTNAME - The topic hostname. Typically it exists in the format "<YOUR-TOPIC-NAME>.<REGION-NAME>.eventgrid.azure.net". """ # [START publish_cloud_event_to_topic] import os from azure.eventgrid import EventGridPublisherClient from azure.core.credentials import AzureKeyCredential from azure.core.messaging import CloudEvent topic_key = os.environ["CLOUD_ACCESS_KEY"] endpoint = os.environ["CLOUD_TOPIC_HOSTNAME"] credential = AzureKeyCredential(topic_key) client = EventGridPublisherClient(endpoint, credential) client.send([ CloudEvent(type="Contoso.Items.ItemReceived", source="/contoso/items", data={"itemSku": "Contoso Item SKU #1"}, subject="Door1") ]) # [END publish_cloud_event_to_topic]
domain_key = os.environ["DOMAIN_ACCESS_KEY"] domain_topic_hostname = os.environ["DOMAIN_TOPIC_HOSTNAME"] domain_name = os.environ["DOMAIN_NAME"] # authenticate client credential = AzureKeyCredential(domain_key) client = EventGridPublisherClient(domain_topic_hostname, credential) # publish events while True: event_list = [] # list of events to publish team_members = [ "Josh", "Kerri", "Kieran", "Laurent", "Lily", "Matt", "Soren", "Srikanta", "Swathi" ] # possible values for data field # create events and append to list for j in range(randint(1, 3)): sample_members = sample(team_members, k=randint( 1, 9)) # select random subset of team members event = CloudEvent(type="Azure.Sdk.Demo", source=domain_name, data={"team": sample_members}) event_list.append(event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))
and sending them as a list. USAGE: python sample_publish_cloud_event_using_dict.py Set the environment variables with your own values before running the sample: 1) EVENTGRID_CLOUD_EVENT_TOPIC_KEY - The access key of your eventgrid account. 2) EVENTGRID_CLOUD_EVENT_TOPIC_ENDPOINT - The topic hostname. Typically it exists in the format "https://<YOUR-TOPIC-NAME>.<REGION-NAME>.eventgrid.azure.net/api/events". """ import os from azure.eventgrid import EventGridPublisherClient from azure.core.credentials import AzureKeyCredential topic_key = os.environ["EVENTGRID_CLOUD_EVENT_TOPIC_KEY"] endpoint = os.environ["EVENTGRID_CLOUD_EVENT_TOPIC_ENDPOINT"] credential = AzureKeyCredential(topic_key) client = EventGridPublisherClient(endpoint, credential) # [START publish_cloud_event_dict] client.send([{ "type": "Contoso.Items.ItemReceived", "source": "/contoso/items", "data": { "itemSku": "Contoso Item SKU #1" }, "subject": "Door1", "specversion": "1.0", "id": "randomclouduuid11" }]) # [END publish_cloud_event_dict]
class EventGridPerfTest(PerfStressTest): def __init__(self, arguments): super().__init__(arguments) # auth configuration topic_key = self.get_from_env("EG_ACCESS_KEY") endpoint = self.get_from_env("EG_TOPIC_HOSTNAME") # Create clients self.publisher_client = SyncPublisherClient( endpoint=endpoint, credential=AzureKeyCredential(topic_key)) self.async_publisher_client = AsyncPublisherClient( endpoint=endpoint, credential=AzureKeyCredential(topic_key)) self.event_list = [] for _ in range(self.args.num_events): self.event_list.append( EventGridEvent( event_type="Contoso.Items.ItemReceived", data={ "services": ["EventGrid", "ServiceBus", "EventHubs", "Storage"] }, subject="Door1", data_version="2.0")) async def close(self): """This is run after cleanup. Use this to close any open handles or clients. """ await self.async_publisher_client.close() await super().close() def run_sync(self): """The synchronous perf test. Try to keep this minimal and focused. Using only a single client API. Avoid putting any ancilliary logic (e.g. generating UUIDs), and put this in the setup/init instead so that we're only measuring the client API call. """ self.publisher_client.send(self.event_list) async def run_async(self): """The asynchronous perf test. Try to keep this minimal and focused. Using only a single client API. Avoid putting any ancilliary logic (e.g. generating UUIDs), and put this in the setup/init instead so that we're only measuring the client API call. """ await self.async_publisher_client.send(self.event_list) @staticmethod def add_arguments(parser): super(EventGridPerfTest, EventGridPerfTest).add_arguments(parser) parser.add_argument( '-n', '--num-events', nargs='?', type=int, help='Number of events to be sent. Defaults to 100', default=100)
# Regular open telemetry usage from here, see https://github.com/open-telemetry/opentelemetry-python # for details from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ConsoleSpanExporter from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor # Simple console exporter exporter = ConsoleSpanExporter() trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(exporter)) # Example with Eventgrid SDKs import os from azure.eventgrid import EventGridPublisherClient, CloudEvent from azure.core.credentials import AzureKeyCredential hostname = os.environ['CLOUD_TOPIC_HOSTNAME'] key = AzureKeyCredential(os.environ['CLOUD_ACCESS_KEY']) cloud_event = CloudEvent(source='demo', type='sdk.demo', data={'test': 'hello'}, extensions={'test': 'maybe'}) with tracer.start_as_current_span(name="MyApplication"): client = EventGridPublisherClient(hostname, key) client.send(cloud_event)
# license information. # -------------------------------------------------------------------------- """ FILE: sample_publish_events_to_a_topic_using_sas_credential.py DESCRIPTION: These samples demonstrate sending an EventGrid Event using a shared access signature for authentication. USAGE: python sample_publish_events_to_a_topic_using_sas_credential.py Set the environment variables with your own values before running the sample: 1) EVENTGRID_SAS - The shared access signature to use Event Grid. This is typically given to you after creating it using the `generate_sas` method. 2) EG_TOPIC_HOSTNAME - The topic hostname. Typically it exists in the format "https://<YOUR-TOPIC-NAME>.<REGION-NAME>.eventgrid.azure.net/api/events". """ import os from azure.eventgrid import EventGridPublisherClient, EventGridEvent, generate_sas from azure.core.credentials import AzureKeyCredential, AzureSasCredential sas = os.environ["EVENTGRID_SAS"] endpoint = os.environ["EG_TOPIC_HOSTNAME"] credential = AzureSasCredential(sas) client = EventGridPublisherClient(endpoint, credential) client.send([ EventGridEvent(event_type="Contoso.Items.ItemReceived", data={"itemSku": "Contoso Item SKU #1"}, subject="Door1", data_version="2.0") ])
These samples demonstrate creating a list of EventGrid Events and sending them as a list to a topic in a domain. USAGE: python sample_publish_eg_events_to_a_domain.py Set the environment variables with your own values before running the sample: 1) EG_ACCESS_KEY - The access key of your eventgrid account. 2) EG_TOPIC_HOSTNAME - The topic hostname. Typically it exists in the format "https://<YOUR-TOPIC-NAME>.<REGION-NAME>.eventgrid.azure.net/api/events". """ import os from azure.eventgrid import EventGridPublisherClient, EventGridEvent from azure.core.credentials import AzureKeyCredential domain_key = os.environ["EG_DOMAIN_ACCESS_KEY"] domain_hostname = os.environ["EG_DOMAIN_TOPIC_HOSTNAME"] credential = AzureKeyCredential(domain_key) client = EventGridPublisherClient(domain_hostname, credential) client.send([ EventGridEvent(topic="MyCustomDomainTopic1", event_type="Contoso.Items.ItemReceived", data={"itemSku": "Contoso Item SKU #1"}, subject="Door1", data_version="2.0"), EventGridEvent(topic="MyCustomDomainTopic2", event_type="Contoso.Items.ItemReceived", data={"itemSku": "Contoso Item SKU #2"}, subject="Door1", data_version="2.0") ])
DESCRIPTION: This sample demonstrates creating sending a cloud event from the CNCF library. USAGE: python sample_publish_cncf_cloud_events.py Set the environment variables with your own values before running the sample: 1) CLOUD_ACCESS_KEY - The access key of your eventgrid account. 2) CLOUD_TOPIC_HOSTNAME - The topic hostname. Typically it exists in the format "https://<YOUR-TOPIC-NAME>.<REGION-NAME>.eventgrid.azure.net/api/events". """ import os from azure.eventgrid import EventGridPublisherClient from azure.core.credentials import AzureKeyCredential from cloudevents.http import CloudEvent topic_key = os.environ["CLOUD_ACCESS_KEY"] endpoint = os.environ["CLOUD_TOPIC_HOSTNAME"] credential = AzureKeyCredential(topic_key) client = EventGridPublisherClient(endpoint, credential) client.send([ CloudEvent( attributes={ "type": "cloudevent", "source": "/cncf/cloud/event/1.0", "subject": "testingcncfevent" }, data=b'This is a cncf cloud event.', ) ])