From ea00257913ed5779ffad27c947686a052d4fcf60 Mon Sep 17 00:00:00 2001 From: API Team Date: Thu, 11 Sep 2025 11:50:14 +0000 Subject: [PATCH] [GitHub Bot] Generated python SDK --- thousandeyes-sdk-administrative/README.md | 2 +- thousandeyes-sdk-agents/README.md | 2 +- .../.openapi-generator/FILES | 4 + thousandeyes-sdk-alerts/README.md | 4 +- thousandeyes-sdk-alerts/docs/AlertDetail.md | 1 + thousandeyes-sdk-alerts/docs/AlertEmbedded.md | 30 ++++++ thousandeyes-sdk-alerts/docs/Asn.md | 32 +++++++ .../src/thousandeyes_sdk/alerts/__init__.py | 2 + .../alerts/models/__init__.py | 2 + .../alerts/models/alert_detail.py | 10 +- .../alerts/models/alert_embedded.py | 91 +++++++++++++++++++ .../src/thousandeyes_sdk/alerts/models/asn.py | 91 +++++++++++++++++++ .../test/test_alerts_api.py | 7 ++ thousandeyes-sdk-bgp-monitors/README.md | 2 +- thousandeyes-sdk-credentials/README.md | 2 +- thousandeyes-sdk-dashboards/README.md | 2 +- thousandeyes-sdk-emulation/README.md | 2 +- thousandeyes-sdk-endpoint-agents/README.md | 2 +- .../docs/AgentSearchFilters.md | 1 + .../docs/ExternalMetadataItem.md | 2 +- .../models/agent_search_filters.py | 6 +- .../models/external_metadata_item.py | 2 +- .../test/test_endpoint_agents_api.py | 1 + .../README.md | 2 +- thousandeyes-sdk-endpoint-labels/README.md | 2 +- .../README.md | 4 +- .../docs/RealUserEndpointTestResultsApi.md | 6 +- .../real_user_endpoint_test_results_api.py | 6 +- thousandeyes-sdk-endpoint-tests/README.md | 2 +- thousandeyes-sdk-event-detection/README.md | 2 +- thousandeyes-sdk-instant-tests/README.md | 2 +- .../docs/WebTransactionInstantTest.md | 2 +- .../docs/WebTransactionInstantTestRequest.md | 2 +- .../docs/WebTransactionInstantTestResponse.md | 2 +- .../docs/WebTransactionProperties.md | 2 +- .../models/web_transaction_instant_test.py | 4 +- .../web_transaction_instant_test_request.py | 4 +- .../web_transaction_instant_test_response.py | 4 +- .../models/web_transaction_properties.py | 4 +- thousandeyes-sdk-internet-insights/README.md | 2 +- thousandeyes-sdk-snapshots/README.md | 2 +- thousandeyes-sdk-streaming/README.md | 4 +- .../docs/CreateStreamResponse.md | 2 +- .../docs/GetStreamResponse.md | 2 +- thousandeyes-sdk-streaming/docs/PutStream.md | 2 +- thousandeyes-sdk-streaming/docs/Stream.md | 2 +- thousandeyes-sdk-streaming/docs/TagMatch.md | 2 +- .../thousandeyes_sdk/streaming/__init__.py | 2 +- .../streaming/api/streaming_api.py | 2 +- .../streaming/models/__init__.py | 2 +- .../streaming/models/api_error.py | 2 +- .../models/api_error_integration_limits.py | 2 +- .../streaming/models/audit_operation.py | 2 +- .../models/audit_operation_with_update.py | 2 +- .../streaming/models/bad_request_error.py | 2 +- .../models/create_stream_response.py | 4 +- .../streaming/models/data_model_version.py | 2 +- .../streaming/models/endpoint_type.py | 2 +- .../streaming/models/exporter_config.py | 2 +- .../models/exporter_config_splunk_hec.py | 2 +- .../streaming/models/filters.py | 2 +- .../streaming/models/filters_test_types.py | 2 +- .../streaming/models/get_stream_response.py | 4 +- .../streaming/models/put_stream.py | 4 +- .../streaming/models/signal.py | 2 +- .../streaming/models/stream.py | 4 +- .../streaming/models/stream_links.py | 2 +- .../streaming/models/stream_response.py | 2 +- .../streaming/models/stream_self_link.py | 2 +- .../streaming/models/stream_status.py | 2 +- .../streaming/models/stream_status_type.py | 2 +- .../streaming/models/stream_type.py | 2 +- .../streaming/models/tag_match.py | 4 +- .../streaming/models/tag_match_object_type.py | 2 +- .../streaming/models/test_match.py | 2 +- .../streaming/models/test_match_domain.py | 2 +- .../streaming/models/test_type.py | 2 +- .../streaming/models/unauthorized_error.py | 2 +- .../test/test_streaming_api.py | 2 +- thousandeyes-sdk-tags/README.md | 2 +- thousandeyes-sdk-test-results/README.md | 2 +- thousandeyes-sdk-tests/README.md | 2 +- .../docs/UnexpandedWebTransactionTest.md | 2 +- .../docs/WebTransactionInstantTest.md | 2 +- .../docs/WebTransactionProperties.md | 2 +- .../docs/WebTransactionTest.md | 2 +- .../docs/WebTransactionTestRequest.md | 2 +- .../docs/WebTransactionTestResponse.md | 2 +- .../models/unexpanded_web_transaction_test.py | 4 +- .../models/web_transaction_instant_test.py | 4 +- .../models/web_transaction_properties.py | 4 +- .../tests/models/web_transaction_test.py | 4 +- .../models/web_transaction_test_request.py | 4 +- .../models/web_transaction_test_response.py | 4 +- thousandeyes-sdk-usage/README.md | 2 +- 95 files changed, 379 insertions(+), 107 deletions(-) create mode 100644 thousandeyes-sdk-alerts/docs/AlertEmbedded.md create mode 100644 thousandeyes-sdk-alerts/docs/Asn.md create mode 100644 thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/alert_embedded.py create mode 100644 thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/asn.py diff --git a/thousandeyes-sdk-administrative/README.md b/thousandeyes-sdk-administrative/README.md index e9ee8f58..306e6589 100644 --- a/thousandeyes-sdk-administrative/README.md +++ b/thousandeyes-sdk-administrative/README.md @@ -12,7 +12,7 @@ This API provides the following operations to manage your organization: This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-agents/README.md b/thousandeyes-sdk-agents/README.md index 909774fe..75c26560 100644 --- a/thousandeyes-sdk-agents/README.md +++ b/thousandeyes-sdk-agents/README.md @@ -5,7 +5,7 @@ Manage Cloud and Enterprise Agents available to your account in ThousandEyes. This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-alerts/.openapi-generator/FILES b/thousandeyes-sdk-alerts/.openapi-generator/FILES index 364fdce1..eeb9f4a7 100644 --- a/thousandeyes-sdk-alerts/.openapi-generator/FILES +++ b/thousandeyes-sdk-alerts/.openapi-generator/FILES @@ -4,6 +4,7 @@ README.md docs/Alert.md docs/AlertDetail.md docs/AlertDirection.md +docs/AlertEmbedded.md docs/AlertGroupType.md docs/AlertLinks.md docs/AlertMeta.md @@ -22,6 +23,7 @@ docs/AlertTestType.md docs/AlertType.md docs/Alerts.md docs/AlertsApi.md +docs/Asn.md docs/BaseAlert.md docs/BaseAlertSuppressionWindow.md docs/BaseRule.md @@ -73,6 +75,7 @@ src/thousandeyes_sdk/alerts/models/__init__.py src/thousandeyes_sdk/alerts/models/alert.py src/thousandeyes_sdk/alerts/models/alert_detail.py src/thousandeyes_sdk/alerts/models/alert_direction.py +src/thousandeyes_sdk/alerts/models/alert_embedded.py src/thousandeyes_sdk/alerts/models/alert_group_type.py src/thousandeyes_sdk/alerts/models/alert_links.py src/thousandeyes_sdk/alerts/models/alert_meta.py @@ -88,6 +91,7 @@ src/thousandeyes_sdk/alerts/models/alert_suppression_windows.py src/thousandeyes_sdk/alerts/models/alert_test_type.py src/thousandeyes_sdk/alerts/models/alert_type.py src/thousandeyes_sdk/alerts/models/alerts.py +src/thousandeyes_sdk/alerts/models/asn.py src/thousandeyes_sdk/alerts/models/base_alert.py src/thousandeyes_sdk/alerts/models/base_alert_suppression_window.py src/thousandeyes_sdk/alerts/models/base_rule.py diff --git a/thousandeyes-sdk-alerts/README.md b/thousandeyes-sdk-alerts/README.md index 867ccc1c..dd794847 100644 --- a/thousandeyes-sdk-alerts/README.md +++ b/thousandeyes-sdk-alerts/README.md @@ -12,7 +12,7 @@ For more information about the alerts, see [Alerts](https://docs.thousandeyes.co This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator @@ -123,6 +123,7 @@ Class | Method | HTTP request | Description - [Alert](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/Alert.md) - [AlertDetail](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/AlertDetail.md) - [AlertDirection](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/AlertDirection.md) + - [AlertEmbedded](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/AlertEmbedded.md) - [AlertGroupType](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/AlertGroupType.md) - [AlertLinks](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/AlertLinks.md) - [AlertMeta](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/AlertMeta.md) @@ -138,6 +139,7 @@ Class | Method | HTTP request | Description - [AlertTestType](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/AlertTestType.md) - [AlertType](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/AlertType.md) - [Alerts](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/Alerts.md) + - [Asn](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/Asn.md) - [BaseAlert](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/BaseAlert.md) - [BaseAlertSuppressionWindow](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/BaseAlertSuppressionWindow.md) - [BaseRule](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-alerts/docs/BaseRule.md) diff --git a/thousandeyes-sdk-alerts/docs/AlertDetail.md b/thousandeyes-sdk-alerts/docs/AlertDetail.md index d803810b..2f602e37 100644 --- a/thousandeyes-sdk-alerts/docs/AlertDetail.md +++ b/thousandeyes-sdk-alerts/docs/AlertDetail.md @@ -19,6 +19,7 @@ Name | Type | Description | Notes **alert_state** | [**State**](State.md) | | [optional] **alert_severity** | [**Severity**](Severity.md) | | [optional] **details** | [**List[AlertMetricDetail]**](AlertMetricDetail.md) | | [optional] +**embedded** | [**AlertEmbedded**](AlertEmbedded.md) | | [optional] ## Example diff --git a/thousandeyes-sdk-alerts/docs/AlertEmbedded.md b/thousandeyes-sdk-alerts/docs/AlertEmbedded.md new file mode 100644 index 00000000..f1c15418 --- /dev/null +++ b/thousandeyes-sdk-alerts/docs/AlertEmbedded.md @@ -0,0 +1,30 @@ +# AlertEmbedded + +Container for embedded resources in alert responses (HATEOAS). + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**asn** | [**Asn**](Asn.md) | | [optional] + +## Example + +```python +from thousandeyes_sdk.alerts.models.alert_embedded import AlertEmbedded + +# TODO update the JSON string below +json = "{}" +# create an instance of AlertEmbedded from a JSON string +alert_embedded_instance = AlertEmbedded.from_json(json) +# print the JSON string representation of the object +print(AlertEmbedded.to_json()) + +# convert the object into a dict +alert_embedded_dict = alert_embedded_instance.to_dict() +# create an instance of AlertEmbedded from a dict +alert_embedded_from_dict = AlertEmbedded.from_dict(alert_embedded_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/thousandeyes-sdk-alerts/docs/Asn.md b/thousandeyes-sdk-alerts/docs/Asn.md new file mode 100644 index 00000000..d32f53fe --- /dev/null +++ b/thousandeyes-sdk-alerts/docs/Asn.md @@ -0,0 +1,32 @@ +# Asn + +Autonomous System Number (ASN) information for network outage alerts. + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **str** | ASN identifier. | [optional] +**name** | **str** | Autonomous system name. | [optional] +**type** | **str** | Resource type. | [optional] + +## Example + +```python +from thousandeyes_sdk.alerts.models.asn import Asn + +# TODO update the JSON string below +json = "{}" +# create an instance of Asn from a JSON string +asn_instance = Asn.from_json(json) +# print the JSON string representation of the object +print(Asn.to_json()) + +# convert the object into a dict +asn_dict = asn_instance.to_dict() +# create an instance of Asn from a dict +asn_from_dict = Asn.from_dict(asn_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/__init__.py b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/__init__.py index 95304b15..b0aa1d40 100644 --- a/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/__init__.py +++ b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/__init__.py @@ -23,6 +23,7 @@ from thousandeyes_sdk.alerts.api.alerts_api import AlertsApi from thousandeyes_sdk.alerts.models.alert import Alert from thousandeyes_sdk.alerts.models.alert_detail import AlertDetail from thousandeyes_sdk.alerts.models.alert_direction import AlertDirection +from thousandeyes_sdk.alerts.models.alert_embedded import AlertEmbedded from thousandeyes_sdk.alerts.models.alert_group_type import AlertGroupType from thousandeyes_sdk.alerts.models.alert_links import AlertLinks from thousandeyes_sdk.alerts.models.alert_meta import AlertMeta @@ -38,6 +39,7 @@ from thousandeyes_sdk.alerts.models.alert_suppression_windows import AlertSuppre from thousandeyes_sdk.alerts.models.alert_test_type import AlertTestType from thousandeyes_sdk.alerts.models.alert_type import AlertType from thousandeyes_sdk.alerts.models.alerts import Alerts +from thousandeyes_sdk.alerts.models.asn import Asn from thousandeyes_sdk.alerts.models.base_alert import BaseAlert from thousandeyes_sdk.alerts.models.base_alert_suppression_window import BaseAlertSuppressionWindow from thousandeyes_sdk.alerts.models.base_rule import BaseRule diff --git a/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/__init__.py b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/__init__.py index 61576c33..063457e5 100644 --- a/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/__init__.py +++ b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/__init__.py @@ -16,6 +16,7 @@ from thousandeyes_sdk.alerts.models.alert import Alert from thousandeyes_sdk.alerts.models.alert_detail import AlertDetail from thousandeyes_sdk.alerts.models.alert_direction import AlertDirection +from thousandeyes_sdk.alerts.models.alert_embedded import AlertEmbedded from thousandeyes_sdk.alerts.models.alert_group_type import AlertGroupType from thousandeyes_sdk.alerts.models.alert_links import AlertLinks from thousandeyes_sdk.alerts.models.alert_meta import AlertMeta @@ -31,6 +32,7 @@ from thousandeyes_sdk.alerts.models.alert_suppression_windows import AlertSuppre from thousandeyes_sdk.alerts.models.alert_test_type import AlertTestType from thousandeyes_sdk.alerts.models.alert_type import AlertType from thousandeyes_sdk.alerts.models.alerts import Alerts +from thousandeyes_sdk.alerts.models.asn import Asn from thousandeyes_sdk.alerts.models.base_alert import BaseAlert from thousandeyes_sdk.alerts.models.base_alert_suppression_window import BaseAlertSuppressionWindow from thousandeyes_sdk.alerts.models.base_rule import BaseRule diff --git a/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/alert_detail.py b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/alert_detail.py index 6a181834..6426862c 100644 --- a/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/alert_detail.py +++ b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/alert_detail.py @@ -19,6 +19,7 @@ import json from datetime import datetime from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr from typing import Any, ClassVar, Dict, List, Optional +from thousandeyes_sdk.alerts.models.alert_embedded import AlertEmbedded from thousandeyes_sdk.alerts.models.alert_links import AlertLinks from thousandeyes_sdk.alerts.models.alert_meta import AlertMeta from thousandeyes_sdk.alerts.models.alert_metric_detail import AlertMetricDetail @@ -46,7 +47,8 @@ class AlertDetail(BaseModel): alert_state: Optional[State] = Field(default=None, alias="alertState") alert_severity: Optional[Severity] = Field(default=None, alias="alertSeverity") details: Optional[List[AlertMetricDetail]] = None - __properties: ClassVar[List[str]] = ["id", "alertType", "startDate", "endDate", "violationCount", "duration", "suppressed", "meta", "_links", "state", "severity", "alertState", "alertSeverity", "details"] + embedded: Optional[AlertEmbedded] = Field(default=None, alias="_embedded") + __properties: ClassVar[List[str]] = ["id", "alertType", "startDate", "endDate", "violationCount", "duration", "suppressed", "meta", "_links", "state", "severity", "alertState", "alertSeverity", "details", "_embedded"] model_config = ConfigDict( populate_by_name=True, @@ -107,6 +109,9 @@ class AlertDetail(BaseModel): if _item: _items.append(_item.to_dict()) _dict['details'] = _items + # override the default output from pydantic by calling `to_dict()` of embedded + if self.embedded: + _dict['_embedded'] = self.embedded.to_dict() return _dict @classmethod @@ -132,7 +137,8 @@ class AlertDetail(BaseModel): "severity": obj.get("severity"), "alertState": obj.get("alertState"), "alertSeverity": obj.get("alertSeverity"), - "details": [AlertMetricDetail.from_dict(_item) for _item in obj["details"]] if obj.get("details") is not None else None + "details": [AlertMetricDetail.from_dict(_item) for _item in obj["details"]] if obj.get("details") is not None else None, + "_embedded": AlertEmbedded.from_dict(obj["_embedded"]) if obj.get("_embedded") is not None else None }) return _obj diff --git a/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/alert_embedded.py b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/alert_embedded.py new file mode 100644 index 00000000..4f205e9f --- /dev/null +++ b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/alert_embedded.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + Alerts API + + You can manage the following alert functionalities on the ThousandEyes platform using the Alerts API: * **Alerts**: Retrieve alert details. Alerts are assigned to tests through alert rules. * **Alert Rules**: Conditions that you configure in order to highlight or be notified of events of interest in your ThousandEyes tests. When an alert rule’s conditions are met, the associated alert is triggered and the alert becomes active. It remains active until the alert is cleared. Alert rules are reusable across multiple tests.. * **Alert Suppression Windows**: Suppress alerts for tests during periods such as planned maintenance. Windows can be one-time events or recurring events to handle periodic occurrences such as monthly downtime for maintenance. For more information about the alerts, see [Alerts](https://docs.thousandeyes.com/product-documentation/alerts). + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict +from typing import Any, ClassVar, Dict, List, Optional +from thousandeyes_sdk.alerts.models.asn import Asn +from typing import Optional, Set +from typing_extensions import Self + +class AlertEmbedded(BaseModel): + """ + Container for embedded resources in alert responses (HATEOAS). + """ # noqa: E501 + asn: Optional[Asn] = None + __properties: ClassVar[List[str]] = ["asn"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + extra="allow", + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return self.model_dump_json(by_alias=True, exclude_unset=True, exclude_none=True) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of AlertEmbedded from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of asn + if self.asn: + _dict['asn'] = self.asn.to_dict() + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of AlertEmbedded from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "asn": Asn.from_dict(obj["asn"]) if obj.get("asn") is not None else None + }) + return _obj + + diff --git a/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/asn.py b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/asn.py new file mode 100644 index 00000000..1967fdf1 --- /dev/null +++ b/thousandeyes-sdk-alerts/src/thousandeyes_sdk/alerts/models/asn.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + Alerts API + + You can manage the following alert functionalities on the ThousandEyes platform using the Alerts API: * **Alerts**: Retrieve alert details. Alerts are assigned to tests through alert rules. * **Alert Rules**: Conditions that you configure in order to highlight or be notified of events of interest in your ThousandEyes tests. When an alert rule’s conditions are met, the associated alert is triggered and the alert becomes active. It remains active until the alert is cleared. Alert rules are reusable across multiple tests.. * **Alert Suppression Windows**: Suppress alerts for tests during periods such as planned maintenance. Windows can be one-time events or recurring events to handle periodic occurrences such as monthly downtime for maintenance. For more information about the alerts, see [Alerts](https://docs.thousandeyes.com/product-documentation/alerts). + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr +from typing import Any, ClassVar, Dict, List, Optional +from typing import Optional, Set +from typing_extensions import Self + +class Asn(BaseModel): + """ + Autonomous System Number (ASN) information for network outage alerts. + """ # noqa: E501 + id: Optional[StrictStr] = Field(default=None, description="ASN identifier.") + name: Optional[StrictStr] = Field(default=None, description="Autonomous system name.") + type: Optional[StrictStr] = Field(default=None, description="Resource type.") + __properties: ClassVar[List[str]] = ["id", "name", "type"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + extra="allow", + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return self.model_dump_json(by_alias=True, exclude_unset=True, exclude_none=True) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of Asn from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of Asn from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "id": obj.get("id"), + "name": obj.get("name"), + "type": obj.get("type") + }) + return _obj + + diff --git a/thousandeyes-sdk-alerts/test/test_alerts_api.py b/thousandeyes-sdk-alerts/test/test_alerts_api.py index f606a963..be249ce2 100644 --- a/thousandeyes-sdk-alerts/test/test_alerts_api.py +++ b/thousandeyes-sdk-alerts/test/test_alerts_api.py @@ -81,6 +81,13 @@ class TestAlertsApi(unittest.TestCase): "alertSeverity" : "major", "duration" : 60, "violationCount" : 2, + "_embedded" : { + "asn" : { + "name" : "Cisco Webex LLC", + "id" : "13445", + "type" : "asn" + } + }, "meta" : { "version" : 1 }, diff --git a/thousandeyes-sdk-bgp-monitors/README.md b/thousandeyes-sdk-bgp-monitors/README.md index 780d6a3e..36ad99f8 100644 --- a/thousandeyes-sdk-bgp-monitors/README.md +++ b/thousandeyes-sdk-bgp-monitors/README.md @@ -9,7 +9,7 @@ For more information about monitors, see [Inside-Out BGP Visibility](https://doc This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-credentials/README.md b/thousandeyes-sdk-credentials/README.md index 23df4a7d..994f8218 100644 --- a/thousandeyes-sdk-credentials/README.md +++ b/thousandeyes-sdk-credentials/README.md @@ -13,7 +13,7 @@ For more information about credentials, see [Working With Secure Credentials](ht This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-dashboards/README.md b/thousandeyes-sdk-dashboards/README.md index 9d9e96ad..5f25596e 100644 --- a/thousandeyes-sdk-dashboards/README.md +++ b/thousandeyes-sdk-dashboards/README.md @@ -3,7 +3,7 @@ Manage ThousandEyes Dashboards. This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-emulation/README.md b/thousandeyes-sdk-emulation/README.md index f50f55d3..6ae5108a 100644 --- a/thousandeyes-sdk-emulation/README.md +++ b/thousandeyes-sdk-emulation/README.md @@ -9,7 +9,7 @@ To access Emulation API operations, the following permissions are required: This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-endpoint-agents/README.md b/thousandeyes-sdk-endpoint-agents/README.md index 78f28a5f..21009819 100644 --- a/thousandeyes-sdk-endpoint-agents/README.md +++ b/thousandeyes-sdk-endpoint-agents/README.md @@ -5,7 +5,7 @@ For more information about Endpoint Agents, see [Endpoint Agents](https://docs.t This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-endpoint-agents/docs/AgentSearchFilters.md b/thousandeyes-sdk-endpoint-agents/docs/AgentSearchFilters.md index 8eec9d3d..0cefefac 100644 --- a/thousandeyes-sdk-endpoint-agents/docs/AgentSearchFilters.md +++ b/thousandeyes-sdk-endpoint-agents/docs/AgentSearchFilters.md @@ -16,6 +16,7 @@ Name | Type | Description | Notes **location_subdivision1_code** | **List[str]** | Filter using the code for the first level administrative division within the country. In US/Canada this is the State, in UK it's the country e.g. `ENG` | [optional] **location_city** | **List[str]** | This is a prefix match on the city name field. The endpoint expects this to contain the name of the city in English. e.g. 'Paris' or '' | [optional] **license_type** | [**List[AgentLicenseType]**](AgentLicenseType.md) | Filter on the agent's license type | [optional] +**any_connect_device_id** | **List[str]** | IDs of devices that has the Cisco Secure Client deployed with the Internet Security module. Returns only agents that have at least one matching `anyConnectDeviceId`. | [optional] ## Example diff --git a/thousandeyes-sdk-endpoint-agents/docs/ExternalMetadataItem.md b/thousandeyes-sdk-endpoint-agents/docs/ExternalMetadataItem.md index 07681ec4..d4e6b2cf 100644 --- a/thousandeyes-sdk-endpoint-agents/docs/ExternalMetadataItem.md +++ b/thousandeyes-sdk-endpoint-agents/docs/ExternalMetadataItem.md @@ -5,7 +5,7 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- -**key** | **str** | Name or identifier of the external metadata property. | [optional] +**key** | **str** | ID of the device that has the Cisco Secure Client deployed with the Internet Security module. | [optional] **value** | **str** | Value of the external metadata property. | [optional] ## Example diff --git a/thousandeyes-sdk-endpoint-agents/src/thousandeyes_sdk/endpoint_agents/models/agent_search_filters.py b/thousandeyes-sdk-endpoint-agents/src/thousandeyes_sdk/endpoint_agents/models/agent_search_filters.py index 9c2c0ea3..0adcf999 100644 --- a/thousandeyes-sdk-endpoint-agents/src/thousandeyes_sdk/endpoint_agents/models/agent_search_filters.py +++ b/thousandeyes-sdk-endpoint-agents/src/thousandeyes_sdk/endpoint_agents/models/agent_search_filters.py @@ -38,7 +38,8 @@ class AgentSearchFilters(BaseModel): location_subdivision1_code: Optional[List[StrictStr]] = Field(default=None, description="Filter using the code for the first level administrative division within the country. In US/Canada this is the State, in UK it's the country e.g. `ENG` ", alias="locationSubdivision1Code") location_city: Optional[List[StrictStr]] = Field(default=None, description="This is a prefix match on the city name field. The endpoint expects this to contain the name of the city in English. e.g. 'Paris' or '' ", alias="locationCity") license_type: Optional[List[AgentLicenseType]] = Field(default=None, description="Filter on the agent's license type ", alias="licenseType") - __properties: ClassVar[List[str]] = ["id", "agentName", "computerName", "username", "userPrincipalName", "platform", "osVersion", "locationCountryISO", "locationSubdivision1Code", "locationCity", "licenseType"] + any_connect_device_id: Optional[List[StrictStr]] = Field(default=None, description="IDs of devices that has the Cisco Secure Client deployed with the Internet Security module. Returns only agents that have at least one matching `anyConnectDeviceId`. ", alias="anyConnectDeviceId") + __properties: ClassVar[List[str]] = ["id", "agentName", "computerName", "username", "userPrincipalName", "platform", "osVersion", "locationCountryISO", "locationSubdivision1Code", "locationCity", "licenseType", "anyConnectDeviceId"] model_config = ConfigDict( populate_by_name=True, @@ -102,7 +103,8 @@ class AgentSearchFilters(BaseModel): "locationCountryISO": obj.get("locationCountryISO"), "locationSubdivision1Code": obj.get("locationSubdivision1Code"), "locationCity": obj.get("locationCity"), - "licenseType": obj.get("licenseType") + "licenseType": obj.get("licenseType"), + "anyConnectDeviceId": obj.get("anyConnectDeviceId") }) return _obj diff --git a/thousandeyes-sdk-endpoint-agents/src/thousandeyes_sdk/endpoint_agents/models/external_metadata_item.py b/thousandeyes-sdk-endpoint-agents/src/thousandeyes_sdk/endpoint_agents/models/external_metadata_item.py index fb7ecdf4..57ade938 100644 --- a/thousandeyes-sdk-endpoint-agents/src/thousandeyes_sdk/endpoint_agents/models/external_metadata_item.py +++ b/thousandeyes-sdk-endpoint-agents/src/thousandeyes_sdk/endpoint_agents/models/external_metadata_item.py @@ -25,7 +25,7 @@ class ExternalMetadataItem(BaseModel): """ ExternalMetadataItem """ # noqa: E501 - key: Optional[StrictStr] = Field(default=None, description="Name or identifier of the external metadata property.") + key: Optional[StrictStr] = Field(default=None, description="ID of the device that has the Cisco Secure Client deployed with the Internet Security module.") value: Optional[StrictStr] = Field(default=None, description="Value of the external metadata property.") __properties: ClassVar[List[str]] = ["key", "value"] diff --git a/thousandeyes-sdk-endpoint-agents/test/test_endpoint_agents_api.py b/thousandeyes-sdk-endpoint-agents/test/test_endpoint_agents_api.py index 9636a0ca..7717eb19 100644 --- a/thousandeyes-sdk-endpoint-agents/test/test_endpoint_agents_api.py +++ b/thousandeyes-sdk-endpoint-agents/test/test_endpoint_agents_api.py @@ -383,6 +383,7 @@ class TestEndpointAgentsApi(unittest.TestCase): "licenseType" : [ "essentials", "essentials" ], "osVersion" : [ "Version 10.15.2", "Version 10.15.2" ], "computerName" : [ "DESKTOP-45AE8", "DESKTOP-45AE8" ], + "anyConnectDeviceId" : [ "JDLKSLFEIJER004334F" ], "locationCountryISO" : [ "FR", "FR" ], "agentName" : [ "myagent-1234", "myagent-1234" ], "locationSubdivision1Code" : [ "ENG", "ENG" ], diff --git a/thousandeyes-sdk-endpoint-instant-tests/README.md b/thousandeyes-sdk-endpoint-instant-tests/README.md index 9101eaf9..5e97cb06 100644 --- a/thousandeyes-sdk-endpoint-instant-tests/README.md +++ b/thousandeyes-sdk-endpoint-instant-tests/README.md @@ -13,7 +13,7 @@ The URLs for these API test data endpoints are provided within the test definiti This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-endpoint-labels/README.md b/thousandeyes-sdk-endpoint-labels/README.md index 21dabd2e..3c87cc17 100644 --- a/thousandeyes-sdk-endpoint-labels/README.md +++ b/thousandeyes-sdk-endpoint-labels/README.md @@ -4,7 +4,7 @@ Manage labels applied to endpoint agents using this API. This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-endpoint-test-results/README.md b/thousandeyes-sdk-endpoint-test-results/README.md index 29322f53..ff5c461b 100644 --- a/thousandeyes-sdk-endpoint-test-results/README.md +++ b/thousandeyes-sdk-endpoint-test-results/README.md @@ -3,7 +3,7 @@ Retrieve results for scheduled and dynamic tests on endpoint agents. This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator @@ -113,7 +113,7 @@ Class | Method | HTTP request | Description *NetworkEndpointScheduledTestResultsApi* | [**filter_scheduled_tests_network_results**](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-endpoint-test-results/docs/NetworkEndpointScheduledTestResultsApi.md#filter_scheduled_tests_network_results) | **POST** /endpoint/test-results/scheduled-tests/network/filter | Retrieve network scheduled test results from multiple tests *NetworkEndpointScheduledTestResultsApi* | [**get_scheduled_test_path_vis_agent_round_results**](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-endpoint-test-results/docs/NetworkEndpointScheduledTestResultsApi.md#get_scheduled_test_path_vis_agent_round_results) | **GET** /endpoint/test-results/scheduled-tests/{testId}/path-vis/agent/{agentId}/round/{roundId} | Retrieve path visualization network scheduled test results details *NetworkEndpointScheduledTestResultsApi* | [**get_scheduled_test_path_vis_results**](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-endpoint-test-results/docs/NetworkEndpointScheduledTestResultsApi.md#get_scheduled_test_path_vis_results) | **GET** /endpoint/test-results/scheduled-tests/{testId}/path-vis | Retrieve path visualization network scheduled test results -*RealUserEndpointTestResultsApi* | [**filter_real_user_tests_network_results**](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md#filter_real_user_tests_network_results) | **POST** /endpoint/test-results/real-user-tests/networks/filter | List endpoint real user tests +*RealUserEndpointTestResultsApi* | [**filter_real_user_tests_network_results**](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md#filter_real_user_tests_network_results) | **POST** /endpoint/test-results/real-user-tests/networks/filter | List endpoint real user tests networks *RealUserEndpointTestResultsApi* | [**filter_real_user_tests_results**](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md#filter_real_user_tests_results) | **POST** /endpoint/test-results/real-user-tests/filter | List endpoint real user tests *RealUserEndpointTestResultsApi* | [**filter_real_user_tests_visited_pages_results**](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md#filter_real_user_tests_visited_pages_results) | **POST** /endpoint/test-results/real-user-tests/pages/filter | List endpoint real user tests visited pages *RealUserEndpointTestResultsApi* | [**get_real_user_test_page_results**](https://github.com/thousandeyes/thousandeyes-sdk-python//tree/main/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md#get_real_user_test_page_results) | **GET** /endpoint/test-results/real-user-tests/{id}/pages/{pageId} | Retrieve endpoint real user test page diff --git a/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md b/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md index 155ef403..d9531b16 100644 --- a/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md +++ b/thousandeyes-sdk-endpoint-test-results/docs/RealUserEndpointTestResultsApi.md @@ -4,7 +4,7 @@ All URIs are relative to *https://api.thousandeyes.com/v7* Method | HTTP request | Description ------------- | ------------- | ------------- -[**filter_real_user_tests_network_results**](RealUserEndpointTestResultsApi.md#filter_real_user_tests_network_results) | **POST** /endpoint/test-results/real-user-tests/networks/filter | List endpoint real user tests +[**filter_real_user_tests_network_results**](RealUserEndpointTestResultsApi.md#filter_real_user_tests_network_results) | **POST** /endpoint/test-results/real-user-tests/networks/filter | List endpoint real user tests networks [**filter_real_user_tests_results**](RealUserEndpointTestResultsApi.md#filter_real_user_tests_results) | **POST** /endpoint/test-results/real-user-tests/filter | List endpoint real user tests [**filter_real_user_tests_visited_pages_results**](RealUserEndpointTestResultsApi.md#filter_real_user_tests_visited_pages_results) | **POST** /endpoint/test-results/real-user-tests/pages/filter | List endpoint real user tests visited pages [**get_real_user_test_page_results**](RealUserEndpointTestResultsApi.md#get_real_user_test_page_results) | **GET** /endpoint/test-results/real-user-tests/{id}/pages/{pageId} | Retrieve endpoint real user test page @@ -14,7 +14,7 @@ Method | HTTP request | Description # **filter_real_user_tests_network_results** > RealUserEndpointTestNetworkResults filter_real_user_tests_network_results(aid=aid, window=window, start_date=start_date, end_date=end_date, cursor=cursor, real_user_endpoint_test_results_request=real_user_endpoint_test_results_request) -List endpoint real user tests +List endpoint real user tests networks Returns a list of all endpoint real user tests. Sessions from the last round are provided unless an explicit start and end is provided with `startDate`, `endDate` or `window` optional parameters. ## Request body filters This endpoint supports complex filtering using the request body. It is important these filters remain unaltered when making use of pagination, otherwise the results will not be coherent with the original request. ### Multiple filter fields When multiple filter fields are provided, a logical `AND` is applied between the filters. ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"platform\": [ \"mac\" ], \"domain\": [ \"thousandeyes.com\" ] }}' ``` ### Filter field with multiple values When a filter field contains multiple values, a logical `OR` is applied between the filter values. ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"networkId\": [ \"660b34109d12\", \"660b34109d15\" ] }}' ``` ### Combination of request parameters and body filters ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter?window=1w' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"platform\": [ \"mac\" ], \"domain\": [ \"thousandeyes.com\" ], \"networkId\": [ \"660b34109d12\", \"660b34109d15\" ] }}' ``` Returns a `results` array of endpoint real user tests. Network sessions shown are from the latest round, or based on the time range specified. @@ -57,7 +57,7 @@ with thousandeyes_sdk.core.ApiClient(configuration) as api_client: real_user_endpoint_test_results_request = thousandeyes_sdk.endpoint_test_results.RealUserEndpointTestResultsRequest() # RealUserEndpointTestResultsRequest | (optional) try: - # List endpoint real user tests + # List endpoint real user tests networks api_response = api_instance.filter_real_user_tests_network_results(aid=aid, window=window, start_date=start_date, end_date=end_date, cursor=cursor, real_user_endpoint_test_results_request=real_user_endpoint_test_results_request) print("The response of RealUserEndpointTestResultsApi->filter_real_user_tests_network_results:\n") pprint(api_response) diff --git a/thousandeyes-sdk-endpoint-test-results/src/thousandeyes_sdk/endpoint_test_results/api/real_user_endpoint_test_results_api.py b/thousandeyes-sdk-endpoint-test-results/src/thousandeyes_sdk/endpoint_test_results/api/real_user_endpoint_test_results_api.py index a51353c1..645433c5 100644 --- a/thousandeyes-sdk-endpoint-test-results/src/thousandeyes_sdk/endpoint_test_results/api/real_user_endpoint_test_results_api.py +++ b/thousandeyes-sdk-endpoint-test-results/src/thousandeyes_sdk/endpoint_test_results/api/real_user_endpoint_test_results_api.py @@ -71,7 +71,7 @@ class RealUserEndpointTestResultsApi: _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RealUserEndpointTestNetworkResults: - """List endpoint real user tests + """List endpoint real user tests networks Returns a list of all endpoint real user tests. Sessions from the last round are provided unless an explicit start and end is provided with `startDate`, `endDate` or `window` optional parameters. ## Request body filters This endpoint supports complex filtering using the request body. It is important these filters remain unaltered when making use of pagination, otherwise the results will not be coherent with the original request. ### Multiple filter fields When multiple filter fields are provided, a logical `AND` is applied between the filters. ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"platform\": [ \"mac\" ], \"domain\": [ \"thousandeyes.com\" ] }}' ``` ### Filter field with multiple values When a filter field contains multiple values, a logical `OR` is applied between the filter values. ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"networkId\": [ \"660b34109d12\", \"660b34109d15\" ] }}' ``` ### Combination of request parameters and body filters ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter?window=1w' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"platform\": [ \"mac\" ], \"domain\": [ \"thousandeyes.com\" ], \"networkId\": [ \"660b34109d12\", \"660b34109d15\" ] }}' ``` Returns a `results` array of endpoint real user tests. Network sessions shown are from the latest round, or based on the time range specified. @@ -166,7 +166,7 @@ class RealUserEndpointTestResultsApi: _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[RealUserEndpointTestNetworkResults]: - """List endpoint real user tests + """List endpoint real user tests networks Returns a list of all endpoint real user tests. Sessions from the last round are provided unless an explicit start and end is provided with `startDate`, `endDate` or `window` optional parameters. ## Request body filters This endpoint supports complex filtering using the request body. It is important these filters remain unaltered when making use of pagination, otherwise the results will not be coherent with the original request. ### Multiple filter fields When multiple filter fields are provided, a logical `AND` is applied between the filters. ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"platform\": [ \"mac\" ], \"domain\": [ \"thousandeyes.com\" ] }}' ``` ### Filter field with multiple values When a filter field contains multiple values, a logical `OR` is applied between the filter values. ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"networkId\": [ \"660b34109d12\", \"660b34109d15\" ] }}' ``` ### Combination of request parameters and body filters ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter?window=1w' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"platform\": [ \"mac\" ], \"domain\": [ \"thousandeyes.com\" ], \"networkId\": [ \"660b34109d12\", \"660b34109d15\" ] }}' ``` Returns a `results` array of endpoint real user tests. Network sessions shown are from the latest round, or based on the time range specified. @@ -261,7 +261,7 @@ class RealUserEndpointTestResultsApi: _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """List endpoint real user tests + """List endpoint real user tests networks Returns a list of all endpoint real user tests. Sessions from the last round are provided unless an explicit start and end is provided with `startDate`, `endDate` or `window` optional parameters. ## Request body filters This endpoint supports complex filtering using the request body. It is important these filters remain unaltered when making use of pagination, otherwise the results will not be coherent with the original request. ### Multiple filter fields When multiple filter fields are provided, a logical `AND` is applied between the filters. ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"platform\": [ \"mac\" ], \"domain\": [ \"thousandeyes.com\" ] }}' ``` ### Filter field with multiple values When a filter field contains multiple values, a logical `OR` is applied between the filter values. ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"networkId\": [ \"660b34109d12\", \"660b34109d15\" ] }}' ``` ### Combination of request parameters and body filters ``` curl --location --request POST 'https://api.thousandeyes.com/v7/endpoint/test-results/real-user-tests/networks/filter?window=1w' --header 'Authorization: Bearer $token' --header 'Content-Type: application/json' --data-raw '{ \"searchFilters\": { \"platform\": [ \"mac\" ], \"domain\": [ \"thousandeyes.com\" ], \"networkId\": [ \"660b34109d12\", \"660b34109d15\" ] }}' ``` Returns a `results` array of endpoint real user tests. Network sessions shown are from the latest round, or based on the time range specified. diff --git a/thousandeyes-sdk-endpoint-tests/README.md b/thousandeyes-sdk-endpoint-tests/README.md index b250efbe..7583deab 100644 --- a/thousandeyes-sdk-endpoint-tests/README.md +++ b/thousandeyes-sdk-endpoint-tests/README.md @@ -5,7 +5,7 @@ Manage endpoint agent dynamic and scheduled tests using the Endpoint Tests API. This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-event-detection/README.md b/thousandeyes-sdk-event-detection/README.md index 7d8de798..6a16553e 100644 --- a/thousandeyes-sdk-event-detection/README.md +++ b/thousandeyes-sdk-event-detection/README.md @@ -12,7 +12,7 @@ With the Events API, you can perform the following tasks on the ThousandEyes pla This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-instant-tests/README.md b/thousandeyes-sdk-instant-tests/README.md index 1c9a2fc1..3d123301 100644 --- a/thousandeyes-sdk-instant-tests/README.md +++ b/thousandeyes-sdk-instant-tests/README.md @@ -6,7 +6,7 @@ The response does not include the immediate test results. Use the Test Results e This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTest.md b/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTest.md index d0db7e20..5efc6996 100644 --- a/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTest.md +++ b/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTest.md @@ -54,7 +54,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTestRequest.md b/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTestRequest.md index 79a569d9..a86082a2 100644 --- a/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTestRequest.md +++ b/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTestRequest.md @@ -54,7 +54,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTestResponse.md b/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTestResponse.md index 901b1d38..3d46f5cf 100644 --- a/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTestResponse.md +++ b/thousandeyes-sdk-instant-tests/docs/WebTransactionInstantTestResponse.md @@ -54,7 +54,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-instant-tests/docs/WebTransactionProperties.md b/thousandeyes-sdk-instant-tests/docs/WebTransactionProperties.md index f5109be3..cb985b58 100644 --- a/thousandeyes-sdk-instant-tests/docs/WebTransactionProperties.md +++ b/thousandeyes-sdk-instant-tests/docs/WebTransactionProperties.md @@ -41,7 +41,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test.py b/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test.py index f15a574e..65f0243a 100644 --- a/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test.py +++ b/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test.py @@ -88,7 +88,7 @@ class WebTransactionInstantTest(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -251,7 +251,7 @@ class WebTransactionInstantTest(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test_request.py b/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test_request.py index ea66fde7..095b9543 100644 --- a/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test_request.py +++ b/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test_request.py @@ -87,7 +87,7 @@ class WebTransactionInstantTestRequest(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -240,7 +240,7 @@ class WebTransactionInstantTestRequest(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test_response.py b/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test_response.py index 73afa9ab..a8ec9e3b 100644 --- a/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test_response.py +++ b/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_instant_test_response.py @@ -89,7 +89,7 @@ class WebTransactionInstantTestResponse(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -260,7 +260,7 @@ class WebTransactionInstantTestResponse(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_properties.py b/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_properties.py index 64875910..c933ece7 100644 --- a/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_properties.py +++ b/thousandeyes-sdk-instant-tests/src/thousandeyes_sdk/instant_tests/models/web_transaction_properties.py @@ -71,7 +71,7 @@ class WebTransactionProperties(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -186,7 +186,7 @@ class WebTransactionProperties(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-internet-insights/README.md b/thousandeyes-sdk-internet-insights/README.md index beedf928..33f316cc 100644 --- a/thousandeyes-sdk-internet-insights/README.md +++ b/thousandeyes-sdk-internet-insights/README.md @@ -14,7 +14,7 @@ For more information about Internet Insights, see the [Internet Insights](https: This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-snapshots/README.md b/thousandeyes-sdk-snapshots/README.md index 5353f7fd..8805a2ff 100644 --- a/thousandeyes-sdk-snapshots/README.md +++ b/thousandeyes-sdk-snapshots/README.md @@ -3,7 +3,7 @@ Creates a new test snapshot in ThousandEyes. This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-streaming/README.md b/thousandeyes-sdk-streaming/README.md index 0893c74f..9dc8e49b 100644 --- a/thousandeyes-sdk-streaming/README.md +++ b/thousandeyes-sdk-streaming/README.md @@ -10,12 +10,12 @@ detail, filter, and push the data to the customer-configured endpoints, dependin * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. -For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). +For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-streaming/docs/CreateStreamResponse.md b/thousandeyes-sdk-streaming/docs/CreateStreamResponse.md index adf13ea1..7363e33f 100644 --- a/thousandeyes-sdk-streaming/docs/CreateStreamResponse.md +++ b/thousandeyes-sdk-streaming/docs/CreateStreamResponse.md @@ -14,7 +14,7 @@ Name | Type | Description | Notes **stream_endpoint_url** | **str** | The URL ThousandEyes sends data stream to. For a URL to be valid, it needs to: - Be syntactically correct. - Be reachable. - Use the HTTPS protocol. - When using the `grpc` endpointType, streamEndpointUrl cannot contain paths: - Valid . `grpc` - `https://example.com` - Invalid . `grpc` - `https://example.com/collector`. - Valid . `http` - `https://example.com/collector`. - When using the `http` endpointType, the operation must match the exact final full URL (including the path if there is one) to which the data will be sent. Examples below: - `https://api.honeycomb.io:443/v1/metrics` - `https://ingest.eu0.signalfx.com/v2/datapoint/otlp` | [optional] **data_model_version** | [**DataModelVersion**](DataModelVersion.md) | | [optional] **custom_headers** | **Dict[str, str]** | Custom headers. | [optional] -**tag_match** | [**List[TagMatch]**](TagMatch.md) | A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. | [optional] +**tag_match** | [**List[TagMatch]**](TagMatch.md) | A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. Tags are invalid if the tag key includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers). | [optional] **test_match** | [**List[TestMatch]**](TestMatch.md) | A collection of tests to be included in the data stream. | [optional] **filters** | [**Filters**](Filters.md) | | [optional] **exporter_config** | [**ExporterConfig**](ExporterConfig.md) | | [optional] diff --git a/thousandeyes-sdk-streaming/docs/GetStreamResponse.md b/thousandeyes-sdk-streaming/docs/GetStreamResponse.md index 002224ee..95a69448 100644 --- a/thousandeyes-sdk-streaming/docs/GetStreamResponse.md +++ b/thousandeyes-sdk-streaming/docs/GetStreamResponse.md @@ -14,7 +14,7 @@ Name | Type | Description | Notes **stream_endpoint_url** | **str** | The URL ThousandEyes sends data stream to. For a URL to be valid, it needs to: - Be syntactically correct. - Be reachable. - Use the HTTPS protocol. - When using the `grpc` endpointType, streamEndpointUrl cannot contain paths: - Valid . `grpc` - `https://example.com` - Invalid . `grpc` - `https://example.com/collector`. - Valid . `http` - `https://example.com/collector`. - When using the `http` endpointType, the operation must match the exact final full URL (including the path if there is one) to which the data will be sent. Examples below: - `https://api.honeycomb.io:443/v1/metrics` - `https://ingest.eu0.signalfx.com/v2/datapoint/otlp` | [optional] **data_model_version** | [**DataModelVersion**](DataModelVersion.md) | | [optional] **custom_headers** | **Dict[str, str]** | Custom headers. | [optional] -**tag_match** | [**List[TagMatch]**](TagMatch.md) | A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. | [optional] +**tag_match** | [**List[TagMatch]**](TagMatch.md) | A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. Tags are invalid if the tag key includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers). | [optional] **test_match** | [**List[TestMatch]**](TestMatch.md) | A collection of tests to be included in the data stream. | [optional] **filters** | [**Filters**](Filters.md) | | [optional] **exporter_config** | [**ExporterConfig**](ExporterConfig.md) | | [optional] diff --git a/thousandeyes-sdk-streaming/docs/PutStream.md b/thousandeyes-sdk-streaming/docs/PutStream.md index 78a4e7c0..40e8addd 100644 --- a/thousandeyes-sdk-streaming/docs/PutStream.md +++ b/thousandeyes-sdk-streaming/docs/PutStream.md @@ -7,7 +7,7 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- **custom_headers** | **Dict[str, str]** | Custom headers. | [optional] **stream_endpoint_url** | **str** | The URL ThousandEyes sends data stream to. For a URL to be valid, it needs to: - Be syntactically correct. - Be reachable. - Use the HTTPS protocol. - When using the `grpc` endpointType, streamEndpointUrl cannot contain paths: - Valid . `grpc` - `https://example.com` - Invalid . `grpc` - `https://example.com/collector`. - Valid . `http` - `https://example.com/collector`. - When using the `http` endpointType, the operation must match the exact final full URL (including the path if there is one) to which the data will be sent. Examples below: - `https://api.honeycomb.io:443/v1/metrics` - `https://ingest.eu0.signalfx.com/v2/datapoint/otlp` | [optional] -**tag_match** | [**List[TagMatch]**](TagMatch.md) | A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. | [optional] +**tag_match** | [**List[TagMatch]**](TagMatch.md) | A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. Tags are invalid if the tag key includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers). | [optional] **test_match** | [**List[TestMatch]**](TestMatch.md) | A collection of tests to be included in the data stream. | [optional] **enabled** | **bool** | Flag to enable or disable the stream integration. | [optional] **filters** | [**Filters**](Filters.md) | | [optional] diff --git a/thousandeyes-sdk-streaming/docs/Stream.md b/thousandeyes-sdk-streaming/docs/Stream.md index d4ba2ff8..f11c2320 100644 --- a/thousandeyes-sdk-streaming/docs/Stream.md +++ b/thousandeyes-sdk-streaming/docs/Stream.md @@ -7,7 +7,7 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- **custom_headers** | **Dict[str, str]** | Custom headers. | [optional] **stream_endpoint_url** | **str** | The URL ThousandEyes sends data stream to. For a URL to be valid, it needs to: - Be syntactically correct. - Be reachable. - Use the HTTPS protocol. - When using the `grpc` endpointType, streamEndpointUrl cannot contain paths: - Valid . `grpc` - `https://example.com` - Invalid . `grpc` - `https://example.com/collector`. - Valid . `http` - `https://example.com/collector`. - When using the `http` endpointType, the operation must match the exact final full URL (including the path if there is one) to which the data will be sent. Examples below: - `https://api.honeycomb.io:443/v1/metrics` - `https://ingest.eu0.signalfx.com/v2/datapoint/otlp` | [optional] -**tag_match** | [**List[TagMatch]**](TagMatch.md) | A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. | [optional] +**tag_match** | [**List[TagMatch]**](TagMatch.md) | A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. Tags are invalid if the tag key includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers). | [optional] **test_match** | [**List[TestMatch]**](TestMatch.md) | A collection of tests to be included in the data stream. | [optional] **enabled** | **bool** | Flag to enable or disable the stream integration. | [optional] **filters** | [**Filters**](Filters.md) | | [optional] diff --git a/thousandeyes-sdk-streaming/docs/TagMatch.md b/thousandeyes-sdk-streaming/docs/TagMatch.md index e686d0d2..6659363b 100644 --- a/thousandeyes-sdk-streaming/docs/TagMatch.md +++ b/thousandeyes-sdk-streaming/docs/TagMatch.md @@ -5,7 +5,7 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- -**key** | **str** | The name of the tag key to match | [optional] +**key** | **str** | The name of the tag key to match. The key is invalid if it includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers). | [optional] **value** | **str** | The value of the tag to match | [optional] ## Example diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/__init__.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/__init__.py index 8841d661..d3fd01d0 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/__init__.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/__init__.py @@ -5,7 +5,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/api/streaming_api.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/api/streaming_api.py index 4e9ba0f5..6fac7f8f 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/api/streaming_api.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/api/streaming_api.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/__init__.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/__init__.py index 30a6a2a0..57d9dbc5 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/__init__.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/__init__.py @@ -4,7 +4,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/api_error.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/api_error.py index 8ffca963..ab742f0a 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/api_error.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/api_error.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/api_error_integration_limits.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/api_error_integration_limits.py index 6cd88a98..d2bf5ba1 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/api_error_integration_limits.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/api_error_integration_limits.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/audit_operation.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/audit_operation.py index da354e7f..cd389e70 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/audit_operation.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/audit_operation.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/audit_operation_with_update.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/audit_operation_with_update.py index a30987da..ba73952f 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/audit_operation_with_update.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/audit_operation_with_update.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/bad_request_error.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/bad_request_error.py index fc947dfb..1ffcba14 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/bad_request_error.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/bad_request_error.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/create_stream_response.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/create_stream_response.py index 84ccc06e..f46cf778 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/create_stream_response.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/create_stream_response.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) @@ -45,7 +45,7 @@ class CreateStreamResponse(BaseModel): stream_endpoint_url: Optional[StrictStr] = Field(default=None, description="The URL ThousandEyes sends data stream to. For a URL to be valid, it needs to: - Be syntactically correct. - Be reachable. - Use the HTTPS protocol. - When using the `grpc` endpointType, streamEndpointUrl cannot contain paths: - Valid . `grpc` - `https://example.com` - Invalid . `grpc` - `https://example.com/collector`. - Valid . `http` - `https://example.com/collector`. - When using the `http` endpointType, the operation must match the exact final full URL (including the path if there is one) to which the data will be sent. Examples below: - `https://api.honeycomb.io:443/v1/metrics` - `https://ingest.eu0.signalfx.com/v2/datapoint/otlp`", alias="streamEndpointUrl") data_model_version: Optional[DataModelVersion] = Field(default=None, alias="dataModelVersion") custom_headers: Optional[Dict[str, StrictStr]] = Field(default=None, description="Custom headers.", alias="customHeaders") - tag_match: Optional[List[TagMatch]] = Field(default=None, description="A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics.", alias="tagMatch") + tag_match: Optional[List[TagMatch]] = Field(default=None, description="A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. Tags are invalid if the tag key includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers).", alias="tagMatch") test_match: Optional[List[TestMatch]] = Field(default=None, description="A collection of tests to be included in the data stream.", alias="testMatch") filters: Optional[Filters] = None exporter_config: Optional[ExporterConfig] = Field(default=None, alias="exporterConfig") diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/data_model_version.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/data_model_version.py index 9fad54e5..c8d8be13 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/data_model_version.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/data_model_version.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/endpoint_type.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/endpoint_type.py index c21582e1..a45daaab 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/endpoint_type.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/endpoint_type.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/exporter_config.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/exporter_config.py index 6c97863f..a279003e 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/exporter_config.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/exporter_config.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/exporter_config_splunk_hec.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/exporter_config_splunk_hec.py index 8c46fe01..55aec2e0 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/exporter_config_splunk_hec.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/exporter_config_splunk_hec.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/filters.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/filters.py index b54b8967..ead2e898 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/filters.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/filters.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/filters_test_types.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/filters_test_types.py index b53c0e9a..f78c777b 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/filters_test_types.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/filters_test_types.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/get_stream_response.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/get_stream_response.py index 5a3d8f15..254a78c9 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/get_stream_response.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/get_stream_response.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) @@ -45,7 +45,7 @@ class GetStreamResponse(BaseModel): stream_endpoint_url: Optional[StrictStr] = Field(default=None, description="The URL ThousandEyes sends data stream to. For a URL to be valid, it needs to: - Be syntactically correct. - Be reachable. - Use the HTTPS protocol. - When using the `grpc` endpointType, streamEndpointUrl cannot contain paths: - Valid . `grpc` - `https://example.com` - Invalid . `grpc` - `https://example.com/collector`. - Valid . `http` - `https://example.com/collector`. - When using the `http` endpointType, the operation must match the exact final full URL (including the path if there is one) to which the data will be sent. Examples below: - `https://api.honeycomb.io:443/v1/metrics` - `https://ingest.eu0.signalfx.com/v2/datapoint/otlp`", alias="streamEndpointUrl") data_model_version: Optional[DataModelVersion] = Field(default=None, alias="dataModelVersion") custom_headers: Optional[Dict[str, StrictStr]] = Field(default=None, description="Custom headers.", alias="customHeaders") - tag_match: Optional[List[TagMatch]] = Field(default=None, description="A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics.", alias="tagMatch") + tag_match: Optional[List[TagMatch]] = Field(default=None, description="A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. Tags are invalid if the tag key includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers).", alias="tagMatch") test_match: Optional[List[TestMatch]] = Field(default=None, description="A collection of tests to be included in the data stream.", alias="testMatch") filters: Optional[Filters] = None exporter_config: Optional[ExporterConfig] = Field(default=None, alias="exporterConfig") diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/put_stream.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/put_stream.py index 7f88a3f5..9304e478 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/put_stream.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/put_stream.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) @@ -31,7 +31,7 @@ class PutStream(BaseModel): """ # noqa: E501 custom_headers: Optional[Dict[str, StrictStr]] = Field(default=None, description="Custom headers.", alias="customHeaders") stream_endpoint_url: Optional[StrictStr] = Field(default=None, description="The URL ThousandEyes sends data stream to. For a URL to be valid, it needs to: - Be syntactically correct. - Be reachable. - Use the HTTPS protocol. - When using the `grpc` endpointType, streamEndpointUrl cannot contain paths: - Valid . `grpc` - `https://example.com` - Invalid . `grpc` - `https://example.com/collector`. - Valid . `http` - `https://example.com/collector`. - When using the `http` endpointType, the operation must match the exact final full URL (including the path if there is one) to which the data will be sent. Examples below: - `https://api.honeycomb.io:443/v1/metrics` - `https://ingest.eu0.signalfx.com/v2/datapoint/otlp`", alias="streamEndpointUrl") - tag_match: Optional[List[TagMatch]] = Field(default=None, description="A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics.", alias="tagMatch") + tag_match: Optional[List[TagMatch]] = Field(default=None, description="A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. Tags are invalid if the tag key includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers).", alias="tagMatch") test_match: Optional[List[TestMatch]] = Field(default=None, description="A collection of tests to be included in the data stream.", alias="testMatch") enabled: Optional[StrictBool] = Field(default=None, description="Flag to enable or disable the stream integration.") filters: Optional[Filters] = None diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/signal.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/signal.py index a0da7f3e..088954f7 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/signal.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/signal.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream.py index fda8523e..98f60dc0 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) @@ -35,7 +35,7 @@ class Stream(BaseModel): """ # noqa: E501 custom_headers: Optional[Dict[str, StrictStr]] = Field(default=None, description="Custom headers.", alias="customHeaders") stream_endpoint_url: Optional[StrictStr] = Field(default=None, description="The URL ThousandEyes sends data stream to. For a URL to be valid, it needs to: - Be syntactically correct. - Be reachable. - Use the HTTPS protocol. - When using the `grpc` endpointType, streamEndpointUrl cannot contain paths: - Valid . `grpc` - `https://example.com` - Invalid . `grpc` - `https://example.com/collector`. - Valid . `http` - `https://example.com/collector`. - When using the `http` endpointType, the operation must match the exact final full URL (including the path if there is one) to which the data will be sent. Examples below: - `https://api.honeycomb.io:443/v1/metrics` - `https://ingest.eu0.signalfx.com/v2/datapoint/otlp`", alias="streamEndpointUrl") - tag_match: Optional[List[TagMatch]] = Field(default=None, description="A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics.", alias="tagMatch") + tag_match: Optional[List[TagMatch]] = Field(default=None, description="A collection of tags that determine what tests are included in the data stream. These tag values are also included as attributes in the data stream metrics. Tags are invalid if the tag key includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers).", alias="tagMatch") test_match: Optional[List[TestMatch]] = Field(default=None, description="A collection of tests to be included in the data stream.", alias="testMatch") enabled: Optional[StrictBool] = Field(default=None, description="Flag to enable or disable the stream integration.") filters: Optional[Filters] = None diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_links.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_links.py index 6b36a230..927d81f8 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_links.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_links.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_response.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_response.py index 2a8bc09b..9218f60c 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_response.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_response.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_self_link.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_self_link.py index b6e99d0d..745870de 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_self_link.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_self_link.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_status.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_status.py index 0aaf794f..2ac5dd92 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_status.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_status.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_status_type.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_status_type.py index eb777408..d3fe40ca 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_status_type.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_status_type.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_type.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_type.py index fcd75b49..894e9799 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_type.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/stream_type.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/tag_match.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/tag_match.py index 7047a8b7..189f8ef4 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/tag_match.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/tag_match.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) @@ -25,7 +25,7 @@ class TagMatch(BaseModel): """ TagMatch """ # noqa: E501 - key: Optional[StrictStr] = Field(default=None, description="The name of the tag key to match") + key: Optional[StrictStr] = Field(default=None, description="The name of the tag key to match. The key is invalid if it includes characters that are not allowed by the [OpenTelemetry naming recommendations for attributes](https://opentelemetry.io/docs/specs/semconv/general/naming/#recommendations-for-application-developers).") value: Optional[StrictStr] = Field(default=None, description="The value of the tag to match") __properties: ClassVar[List[str]] = ["key", "value"] diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/tag_match_object_type.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/tag_match_object_type.py index 8bd94cc9..ef9afb34 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/tag_match_object_type.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/tag_match_object_type.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_match.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_match.py index 66fe433c..25ef4959 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_match.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_match.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_match_domain.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_match_domain.py index 220a41e7..4bbb58ea 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_match_domain.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_match_domain.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_type.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_type.py index 03d0a6b0..82dfaef3 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_type.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/test_type.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/unauthorized_error.py b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/unauthorized_error.py index f3309f10..46843011 100644 --- a/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/unauthorized_error.py +++ b/thousandeyes-sdk-streaming/src/thousandeyes_sdk/streaming/models/unauthorized_error.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-streaming/test/test_streaming_api.py b/thousandeyes-sdk-streaming/test/test_streaming_api.py index 3d4f669b..dfd47da8 100644 --- a/thousandeyes-sdk-streaming/test/test_streaming_api.py +++ b/thousandeyes-sdk-streaming/test/test_streaming_api.py @@ -3,7 +3,7 @@ """ ThousandEyes for OpenTelemetry API - ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [documentation](https://docs.thousandeyes.com/product-documentation/api/opentelemetry). + ThousandEyes for OpenTelemetry provides machine-to-machine integration between ThousandEyes and its customers. It allows you to export ThousandEyes telemetry data in OTel format, which is widely used in the industry. With ThousandEyes for OTel, you can leverage frameworks widely used in the observability domain - such as Splunk, Grafana, and Honeycomb - to capture and analyze ThousandEyes data. Any client that supports OTel can use ThousandEyes for OpenTelemetry. ThousandEyes for OTel is made up of the following components: * Data streaming APIs that you can use to configure and enable your ThousandEyes tests with OTel-compatible streams, in particular to configure how ThousandEyes telemetry data is exported to client integrations. * A set of streaming pipelines called _collectors_ that actively fetch ThousandEyes network test data, enrich the data with some additional detail, filter, and push the data to the customer-configured endpoints, depending on what you configure via the public APIs. * Third-party OTel collectors that receive, transform, filter, and export different metrics to client applications such as AppD, or any other OTel-capable client configuration. For more information about ThousandEyes for OpenTelemetry, see the [product documentation](https://docs.thousandeyes.com/product-documentation/integration-guides/opentelemetry). Generated by OpenAPI Generator (https://openapi-generator.tech) diff --git a/thousandeyes-sdk-tags/README.md b/thousandeyes-sdk-tags/README.md index 20670c18..912c3ee1 100644 --- a/thousandeyes-sdk-tags/README.md +++ b/thousandeyes-sdk-tags/README.md @@ -16,7 +16,7 @@ Things to note with the ThousandEyes Tags API: This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-test-results/README.md b/thousandeyes-sdk-test-results/README.md index a40e60c8..874ca207 100644 --- a/thousandeyes-sdk-test-results/README.md +++ b/thousandeyes-sdk-test-results/README.md @@ -3,7 +3,7 @@ Get test result metrics for Network and Application Synthetics tests. This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-tests/README.md b/thousandeyes-sdk-tests/README.md index 132369d9..688b9619 100644 --- a/thousandeyes-sdk-tests/README.md +++ b/thousandeyes-sdk-tests/README.md @@ -4,7 +4,7 @@ This API allows you to list, create, edit, and delete Network and Application Sy This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator diff --git a/thousandeyes-sdk-tests/docs/UnexpandedWebTransactionTest.md b/thousandeyes-sdk-tests/docs/UnexpandedWebTransactionTest.md index 7acd3869..2d971e23 100644 --- a/thousandeyes-sdk-tests/docs/UnexpandedWebTransactionTest.md +++ b/thousandeyes-sdk-tests/docs/UnexpandedWebTransactionTest.md @@ -55,7 +55,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-tests/docs/WebTransactionInstantTest.md b/thousandeyes-sdk-tests/docs/WebTransactionInstantTest.md index 34938765..7c68d1f3 100644 --- a/thousandeyes-sdk-tests/docs/WebTransactionInstantTest.md +++ b/thousandeyes-sdk-tests/docs/WebTransactionInstantTest.md @@ -54,7 +54,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-tests/docs/WebTransactionProperties.md b/thousandeyes-sdk-tests/docs/WebTransactionProperties.md index 3c2c2dda..82ef460b 100644 --- a/thousandeyes-sdk-tests/docs/WebTransactionProperties.md +++ b/thousandeyes-sdk-tests/docs/WebTransactionProperties.md @@ -41,7 +41,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-tests/docs/WebTransactionTest.md b/thousandeyes-sdk-tests/docs/WebTransactionTest.md index fe542094..4f54c3de 100644 --- a/thousandeyes-sdk-tests/docs/WebTransactionTest.md +++ b/thousandeyes-sdk-tests/docs/WebTransactionTest.md @@ -58,7 +58,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-tests/docs/WebTransactionTestRequest.md b/thousandeyes-sdk-tests/docs/WebTransactionTestRequest.md index 7bf0ca89..545aaf0d 100644 --- a/thousandeyes-sdk-tests/docs/WebTransactionTestRequest.md +++ b/thousandeyes-sdk-tests/docs/WebTransactionTestRequest.md @@ -58,7 +58,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-tests/docs/WebTransactionTestResponse.md b/thousandeyes-sdk-tests/docs/WebTransactionTestResponse.md index 421a4557..7d2b07a5 100644 --- a/thousandeyes-sdk-tests/docs/WebTransactionTestResponse.md +++ b/thousandeyes-sdk-tests/docs/WebTransactionTestResponse.md @@ -58,7 +58,7 @@ Name | Type | Description | Notes **override_proxy_id** | **str** | ID of the proxy to be used if the default proxy is overridden. | [optional] **collect_proxy_network_data** | **bool** | Indicates whether network data to the proxy should be collected. | [optional] [default to False] **emulated_device_id** | **str** | ID of the emulated device, if specified when the test was created. | [optional] -**target_time** | **int** | Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior). | [optional] +**target_time** | **int** | Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value. | [optional] [default to 10] **time_limit** | **int** | Time limit for transaction in seconds. | [optional] [default to 30] **transaction_script** | **str** | JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ). | **block_domains** | **str** | Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests. | [optional] diff --git a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/unexpanded_web_transaction_test.py b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/unexpanded_web_transaction_test.py index 3dac6b10..ac901da2 100644 --- a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/unexpanded_web_transaction_test.py +++ b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/unexpanded_web_transaction_test.py @@ -89,7 +89,7 @@ class UnexpandedWebTransactionTest(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -237,7 +237,7 @@ class UnexpandedWebTransactionTest(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_instant_test.py b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_instant_test.py index c6f539c6..f2bcd3db 100644 --- a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_instant_test.py +++ b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_instant_test.py @@ -88,7 +88,7 @@ class WebTransactionInstantTest(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -251,7 +251,7 @@ class WebTransactionInstantTest(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_properties.py b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_properties.py index a4322980..b21e7b80 100644 --- a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_properties.py +++ b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_properties.py @@ -71,7 +71,7 @@ class WebTransactionProperties(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -186,7 +186,7 @@ class WebTransactionProperties(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test.py b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test.py index c35c7271..bd0cefe9 100644 --- a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test.py +++ b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test.py @@ -96,7 +96,7 @@ class WebTransactionTest(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -283,7 +283,7 @@ class WebTransactionTest(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test_request.py b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test_request.py index 962e1a30..b1a8ca38 100644 --- a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test_request.py +++ b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test_request.py @@ -93,7 +93,7 @@ class WebTransactionTestRequest(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -254,7 +254,7 @@ class WebTransactionTestRequest(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test_response.py b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test_response.py index 819084bc..7cf1191a 100644 --- a/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test_response.py +++ b/thousandeyes-sdk-tests/src/thousandeyes_sdk/tests/models/web_transaction_test_response.py @@ -97,7 +97,7 @@ class WebTransactionTestResponse(BaseModel): override_proxy_id: Optional[StrictStr] = Field(default=None, description="ID of the proxy to be used if the default proxy is overridden.", alias="overrideProxyId") collect_proxy_network_data: Optional[StrictBool] = Field(default=False, description="Indicates whether network data to the proxy should be collected.", alias="collectProxyNetworkData") emulated_device_id: Optional[StrictStr] = Field(default=None, description="ID of the emulated device, if specified when the test was created.", alias="emulatedDeviceId") - target_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Target completion time. The default is 50% of the specified time limit in seconds. (Set to 0 to use the default behavior).", alias="targetTime") + target_time: Optional[Annotated[int, Field(le=180, strict=True, ge=0)]] = Field(default=10, description="Target completion time, in seconds. Defaults to 10. Cannot exceed the `timeLimit` value.", alias="targetTime") time_limit: Optional[Annotated[int, Field(le=180, strict=True, ge=5)]] = Field(default=30, description="Time limit for transaction in seconds.", alias="timeLimit") transaction_script: StrictStr = Field(description="JavaScript of a web transaction test. Quotes must be escaped (precede \" characters with \\ ).", alias="transactionScript") block_domains: Optional[StrictStr] = Field(default=None, description="Domains or full object URLs to be excluded from metrics and waterfall data for transaction tests.", alias="blockDomains") @@ -292,7 +292,7 @@ class WebTransactionTestResponse(BaseModel): "overrideProxyId": obj.get("overrideProxyId"), "collectProxyNetworkData": obj.get("collectProxyNetworkData") if obj.get("collectProxyNetworkData") is not None else False, "emulatedDeviceId": obj.get("emulatedDeviceId"), - "targetTime": obj.get("targetTime"), + "targetTime": obj.get("targetTime") if obj.get("targetTime") is not None else 10, "timeLimit": obj.get("timeLimit") if obj.get("timeLimit") is not None else 30, "transactionScript": obj.get("transactionScript"), "blockDomains": obj.get("blockDomains"), diff --git a/thousandeyes-sdk-usage/README.md b/thousandeyes-sdk-usage/README.md index 4be42a6d..3b740eca 100644 --- a/thousandeyes-sdk-usage/README.md +++ b/thousandeyes-sdk-usage/README.md @@ -17,7 +17,7 @@ Refer to the Usage API operations for detailed usage instructions and optional p This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: -- API version: 7.0.58 +- API version: 7.0.62 - Generator version: 7.6.0 - Build package: com.thousandeyes.api.codegen.ThousandeyesPythonGenerator