armdynatrace

package module
v2.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 23, 2023 License: MIT Imports: 14 Imported by: 1

README

Azure Dynatrace Module for Go

PkgGoDev

The armdynatrace module provides operations for working with Azure Dynatrace.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Dynatrace module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/dynatrace/armdynatrace

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Dynatrace. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Dynatrace module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armdynatrace.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armdynatrace.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewMonitorsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Dynatrace label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountInfo 

type AccountInfo struct {
	// Account Id of the account this environment is linked to
	AccountID *string

	// Region in which the account is created
	RegionID *string
}

AccountInfo - Dynatrace Account Information

func (AccountInfo) MarshalJSON 

func (a AccountInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccountInfo.

func (*AccountInfo) UnmarshalJSON 

func (a *AccountInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccountInfo.

type ActionType 

type ActionType string

ActionType - Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type AppServiceInfo 

type AppServiceInfo struct {
	// Update settings of OneAgent.
	AutoUpdateSetting *AutoUpdateSetting

	// The availability state of OneAgent.
	AvailabilityState *AvailabilityState

	// The name of the host group
	HostGroup *string

	// The name of the host
	HostName *string

	// Tells whether log modules are enabled or not
	LogModule *LogModule

	// The monitoring mode of OneAgent
	MonitoringType *MonitoringType

	// App service resource ID
	ResourceID *string

	// The current update status of OneAgent.
	UpdateStatus *UpdateStatus

	// Version of the Dynatrace agent installed on the App Service.
	Version *string
}

AppServiceInfo - Details of App Services having Dynatrace OneAgent installed

func (AppServiceInfo) MarshalJSON 

func (a AppServiceInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AppServiceInfo.

func (*AppServiceInfo) UnmarshalJSON 

func (a *AppServiceInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AppServiceInfo.

type AppServiceListResponse 

type AppServiceListResponse struct {
	// The link to the next page of items
	NextLink *string

	// The items on this page
	Value []*AppServiceInfo
}

AppServiceListResponse - Response of a list App Services Operation.

func (AppServiceListResponse) MarshalJSON 

func (a AppServiceListResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AppServiceListResponse.

func (*AppServiceListResponse) UnmarshalJSON 

func (a *AppServiceListResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AppServiceListResponse.

type AutoUpdateSetting 

type AutoUpdateSetting string

AutoUpdateSetting - Update settings of OneAgent. 

const (
	AutoUpdateSettingDISABLED AutoUpdateSetting = "DISABLED"
	AutoUpdateSettingENABLED  AutoUpdateSetting = "ENABLED"
)

func PossibleAutoUpdateSettingValues 

func PossibleAutoUpdateSettingValues() []AutoUpdateSetting

PossibleAutoUpdateSettingValues returns the possible values for the AutoUpdateSetting const type.

type AvailabilityState 

type AvailabilityState string

AvailabilityState - The availability state of OneAgent. 

const (
	AvailabilityStateCRASHED            AvailabilityState = "CRASHED"
	AvailabilityStateLOST               AvailabilityState = "LOST"
	AvailabilityStateMONITORED          AvailabilityState = "MONITORED"
	AvailabilityStatePREMONITORED       AvailabilityState = "PRE_MONITORED"
	AvailabilityStateSHUTDOWN           AvailabilityState = "SHUTDOWN"
	AvailabilityStateUNEXPECTEDSHUTDOWN AvailabilityState = "UNEXPECTED_SHUTDOWN"
	AvailabilityStateUNKNOWN            AvailabilityState = "UNKNOWN"
	AvailabilityStateUNMONITORED        AvailabilityState = "UNMONITORED"
)

func PossibleAvailabilityStateValues 

func PossibleAvailabilityStateValues() []AvailabilityState

PossibleAvailabilityStateValues returns the possible values for the AvailabilityState const type.

type ClientFactory 

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewMonitorsClient 

func (c *ClientFactory) NewMonitorsClient() *MonitorsClient

NewMonitorsClient creates a new instance of MonitorsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewSingleSignOnClient 

func (c *ClientFactory) NewSingleSignOnClient() *SingleSignOnClient

NewSingleSignOnClient creates a new instance of SingleSignOnClient.

func (*ClientFactory) NewTagRulesClient 

func (c *ClientFactory) NewTagRulesClient() *TagRulesClient

NewTagRulesClient creates a new instance of TagRulesClient.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type EnvironmentInfo 

type EnvironmentInfo struct {
	// Id of the environment created
	EnvironmentID *string

	// Ingestion key of the environment
	IngestionKey *string

	// Landing URL for Dynatrace environment
	LandingURL *string

	// Ingestion endpoint used for sending logs
	LogsIngestionEndpoint *string
}

EnvironmentInfo - Dynatrace Environment Information

func (EnvironmentInfo) MarshalJSON 

func (e EnvironmentInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EnvironmentInfo.

func (*EnvironmentInfo) UnmarshalJSON 

func (e *EnvironmentInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EnvironmentInfo.

type EnvironmentProperties 

type EnvironmentProperties struct {
	// Dynatrace Account Information
	AccountInfo *AccountInfo

	// Dynatrace Environment Information
	EnvironmentInfo *EnvironmentInfo

	// The details of a Dynatrace single sign-on.
	SingleSignOnProperties *SingleSignOnProperties

	// User id
	UserID *string
}

EnvironmentProperties - Properties of the Dynatrace environment.

func (EnvironmentProperties) MarshalJSON 

func (e EnvironmentProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EnvironmentProperties.

func (*EnvironmentProperties) UnmarshalJSON 

func (e *EnvironmentProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EnvironmentProperties.

type FilteringTag 

type FilteringTag struct {
	// Valid actions for a filtering tag. Exclusion takes priority over inclusion.
	Action *TagAction

	// The name (also known as the key) of the tag.
	Name *string

	// The value of the tag.
	Value *string
}

FilteringTag - The definition of a filtering tag. Filtering tags are used for capturing resources and include/exclude them from being monitored.

func (FilteringTag) MarshalJSON 

func (f FilteringTag) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FilteringTag.

func (*FilteringTag) UnmarshalJSON 

func (f *FilteringTag) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FilteringTag.

type IdentityProperties 

type IdentityProperties struct {
	// REQUIRED; The type of managed identity assigned to this resource.
	Type *ManagedIdentityType

	// The identities assigned to this resource by the user.
	UserAssignedIdentities map[string]*UserAssignedIdentity

	// READ-ONLY; The active directory identifier of this principal.
	PrincipalID *string

	// READ-ONLY; The Active Directory tenant id of the principal.
	TenantID *string
}

IdentityProperties - The properties of the managed service identities assigned to this resource.

func (IdentityProperties) MarshalJSON 

func (i IdentityProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IdentityProperties.

func (*IdentityProperties) UnmarshalJSON 

func (i *IdentityProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IdentityProperties.

type LiftrResourceCategories 

type LiftrResourceCategories string

LiftrResourceCategories - Liftr resource category 

const (
	LiftrResourceCategoriesMonitorLogs LiftrResourceCategories = "MonitorLogs"
	LiftrResourceCategoriesUnknown     LiftrResourceCategories = "Unknown"
)

func PossibleLiftrResourceCategoriesValues 

func PossibleLiftrResourceCategoriesValues() []LiftrResourceCategories

PossibleLiftrResourceCategoriesValues returns the possible values for the LiftrResourceCategories const type.

type LinkableEnvironmentListResponse 

type LinkableEnvironmentListResponse struct {
	// Link to the next set of results, if any.
	NextLink *string

	// List of environments for which user is an admin
	Value []*LinkableEnvironmentResponse
}

LinkableEnvironmentListResponse - Response for getting all the linkable environments

func (LinkableEnvironmentListResponse) MarshalJSON 

func (l LinkableEnvironmentListResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinkableEnvironmentListResponse.

func (*LinkableEnvironmentListResponse) UnmarshalJSON 

func (l *LinkableEnvironmentListResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinkableEnvironmentListResponse.

type LinkableEnvironmentRequest 

type LinkableEnvironmentRequest struct {
	// REQUIRED; Azure region in which we want to link the environment
	Region *string

	// REQUIRED; Tenant Id of the user in which they want to link the environment
	TenantID *string

	// REQUIRED; user principal id of the user
	UserPrincipal *string
}

LinkableEnvironmentRequest - Request for getting all the linkable environments for a user

func (LinkableEnvironmentRequest) MarshalJSON 

func (l LinkableEnvironmentRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinkableEnvironmentRequest.

func (*LinkableEnvironmentRequest) UnmarshalJSON 

func (l *LinkableEnvironmentRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinkableEnvironmentRequest.

type LinkableEnvironmentResponse 

type LinkableEnvironmentResponse struct {
	// environment id for which user is an admin
	EnvironmentID *string

	// Name of the environment
	EnvironmentName *string

	// Billing plan information.
	PlanData *PlanData
}

LinkableEnvironmentResponse - Response for getting all the linkable environments

func (LinkableEnvironmentResponse) MarshalJSON 

func (l LinkableEnvironmentResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinkableEnvironmentResponse.

func (*LinkableEnvironmentResponse) UnmarshalJSON 

func (l *LinkableEnvironmentResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinkableEnvironmentResponse.

type LogModule 

type LogModule string

LogModule - Tells whether log modules are enabled or not 

const (
	LogModuleDISABLED LogModule = "DISABLED"
	LogModuleENABLED  LogModule = "ENABLED"
)

func PossibleLogModuleValues 

func PossibleLogModuleValues() []LogModule

PossibleLogModuleValues returns the possible values for the LogModule const type.

type LogRules 

type LogRules struct {
	// List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty,
	// all resources will be captured. If only Exclude action is specified, the
	// rules will apply to the list of all available resources. If Include actions are specified, the rules will only include
	// resources with the associated tags.
	FilteringTags []*FilteringTag

	// Flag specifying if AAD logs should be sent for the Monitor resource.
	SendAADLogs *SendAADLogsStatus

	// Flag specifying if activity logs from Azure resources should be sent for the Monitor resource.
	SendActivityLogs *SendActivityLogsStatus

	// Flag specifying if subscription logs should be sent for the Monitor resource.
	SendSubscriptionLogs *SendSubscriptionLogsStatus
}

LogRules - Set of rules for sending logs for the Monitor resource.

func (LogRules) MarshalJSON 

func (l LogRules) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LogRules.

func (*LogRules) UnmarshalJSON 

func (l *LogRules) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LogRules.

type ManagedIdentityType 

type ManagedIdentityType string

ManagedIdentityType - The kind of managed identity assigned to this resource. 

const (
	ManagedIdentityTypeSystemAndUserAssigned ManagedIdentityType = "SystemAndUserAssigned"
	ManagedIdentityTypeSystemAssigned        ManagedIdentityType = "SystemAssigned"
	ManagedIdentityTypeUserAssigned          ManagedIdentityType = "UserAssigned"
)

func PossibleManagedIdentityTypeValues 

func PossibleManagedIdentityTypeValues() []ManagedIdentityType

PossibleManagedIdentityTypeValues returns the possible values for the ManagedIdentityType const type.

type MarketplaceSaaSResourceDetailsRequest 

type MarketplaceSaaSResourceDetailsRequest struct {
	// REQUIRED; Tenant Id
	TenantID *string
}

MarketplaceSaaSResourceDetailsRequest - Request for getting Marketplace SaaS resource details for a tenant Id

func (MarketplaceSaaSResourceDetailsRequest) MarshalJSON 

func (m MarketplaceSaaSResourceDetailsRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MarketplaceSaaSResourceDetailsRequest.

func (*MarketplaceSaaSResourceDetailsRequest) UnmarshalJSON 

func (m *MarketplaceSaaSResourceDetailsRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MarketplaceSaaSResourceDetailsRequest.

type MarketplaceSaaSResourceDetailsResponse 

type MarketplaceSaaSResourceDetailsResponse struct {
	// Id of the Marketplace SaaS Resource
	MarketplaceSaaSResourceID *string

	// Marketplace subscription status
	MarketplaceSubscriptionStatus *MarketplaceSubscriptionStatus

	// Id of the plan
	PlanID *string
}

MarketplaceSaaSResourceDetailsResponse - Marketplace SaaS resource details linked to the given tenant Id

func (MarketplaceSaaSResourceDetailsResponse) MarshalJSON 

func (m MarketplaceSaaSResourceDetailsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MarketplaceSaaSResourceDetailsResponse.

func (*MarketplaceSaaSResourceDetailsResponse) UnmarshalJSON 

func (m *MarketplaceSaaSResourceDetailsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MarketplaceSaaSResourceDetailsResponse.

type MarketplaceSubscriptionStatus 

type MarketplaceSubscriptionStatus string

MarketplaceSubscriptionStatus - Flag specifying the Marketplace Subscription Status of the resource. If payment is not made in time, the resource will go in Suspended state. 

const (
	MarketplaceSubscriptionStatusActive    MarketplaceSubscriptionStatus = "Active"
	MarketplaceSubscriptionStatusSuspended MarketplaceSubscriptionStatus = "Suspended"
)

func PossibleMarketplaceSubscriptionStatusValues 

func PossibleMarketplaceSubscriptionStatusValues() []MarketplaceSubscriptionStatus

PossibleMarketplaceSubscriptionStatusValues returns the possible values for the MarketplaceSubscriptionStatus const type.

type MetricRules 

type MetricRules struct {
	// List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action
	// is specified, the rules will apply to the list of all available resources. If
	// Include actions are specified, the rules will only include resources with the associated tags.
	FilteringTags []*FilteringTag

	// Flag specifying if metrics from Azure resources should be sent for the Monitor resource.
	SendingMetrics *SendingMetricsStatus
}

MetricRules - Set of rules for sending metrics for the Monitor resource.

func (MetricRules) MarshalJSON 

func (m MetricRules) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricRules.

func (*MetricRules) UnmarshalJSON 

func (m *MetricRules) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricRules.

type MetricsStatusResponse 

type MetricsStatusResponse struct {
	// Azure resource IDs
	AzureResourceIDs []*string
}

MetricsStatusResponse - Response of get metrics status operation

func (MetricsStatusResponse) MarshalJSON 

func (m MetricsStatusResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricsStatusResponse.

func (*MetricsStatusResponse) UnmarshalJSON 

func (m *MetricsStatusResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricsStatusResponse.

type MonitorProperties 

type MonitorProperties struct {
	// Properties of the Dynatrace environment.
	DynatraceEnvironmentProperties *EnvironmentProperties

	// Marketplace subscription status.
	MarketplaceSubscriptionStatus *MarketplaceSubscriptionStatus

	// Status of the monitor.
	MonitoringStatus *MonitoringStatus

	// Billing plan information.
	PlanData *PlanData

	// User info.
	UserInfo *UserInfo

	// READ-ONLY; Liftr Resource category.
	LiftrResourceCategory *LiftrResourceCategories

	// READ-ONLY; The priority of the resource.
	LiftrResourcePreference *int32

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

MonitorProperties - Properties specific to the monitor resource.

func (MonitorProperties) MarshalJSON 

func (m MonitorProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MonitorProperties.

func (*MonitorProperties) UnmarshalJSON 

func (m *MonitorProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MonitorProperties.

type MonitorResource 

type MonitorResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; The resource-specific properties for this resource.
	Properties *MonitorProperties

	// The managed service identities assigned to this resource.
	Identity *IdentityProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; System metadata for this resource.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

MonitorResource - Dynatrace Monitor Resource

func (MonitorResource) MarshalJSON 

func (m MonitorResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MonitorResource.

func (*MonitorResource) UnmarshalJSON 

func (m *MonitorResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MonitorResource.

type MonitorResourceListResult 

type MonitorResourceListResult struct {
	// REQUIRED; The items on this page
	Value []*MonitorResource

	// The link to the next page of items
	NextLink *string
}

MonitorResourceListResult - The response of a MonitorResource list operation.

func (MonitorResourceListResult) MarshalJSON 

func (m MonitorResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MonitorResourceListResult.

func (*MonitorResourceListResult) UnmarshalJSON 

func (m *MonitorResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MonitorResourceListResult.

type MonitorResourceUpdate 

type MonitorResourceUpdate struct {
	// Resource tags.
	Tags map[string]*string
}

MonitorResourceUpdate - The updatable properties of the MonitorResource.

func (MonitorResourceUpdate) MarshalJSON 

func (m MonitorResourceUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MonitorResourceUpdate.

func (*MonitorResourceUpdate) UnmarshalJSON 

func (m *MonitorResourceUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MonitorResourceUpdate.

type MonitoredResource 

type MonitoredResource struct {
	// The ARM id of the resource.
	ID *string

	// Reason for why the resource is sending logs (or why it is not sending).
	ReasonForLogsStatus *string

	// Reason for why the resource is sending metrics (or why it is not sending).
	ReasonForMetricsStatus *string

	// Flag indicating if resource is sending logs to Dynatrace.
	SendingLogs *SendingLogsStatus

	// Flag indicating if resource is sending metrics to Dynatrace.
	SendingMetrics *SendingMetricsStatus
}

MonitoredResource - Details of resource being monitored by Dynatrace monitor resource

func (MonitoredResource) MarshalJSON 

func (m MonitoredResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MonitoredResource.

func (*MonitoredResource) UnmarshalJSON 

func (m *MonitoredResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MonitoredResource.

type MonitoredResourceListResponse 

type MonitoredResourceListResponse struct {
	// The link to the next page of items
	NextLink *string

	// The items on this page
	Value []*MonitoredResource
}

MonitoredResourceListResponse - List of all the resources being monitored by Dynatrace monitor resource

func (MonitoredResourceListResponse) MarshalJSON 

func (m MonitoredResourceListResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MonitoredResourceListResponse.

func (*MonitoredResourceListResponse) UnmarshalJSON 

func (m *MonitoredResourceListResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MonitoredResourceListResponse.

type MonitoringStatus 

type MonitoringStatus string

MonitoringStatus - Flag specifying if the resource monitoring is enabled or disabled. 

const (
	MonitoringStatusDisabled MonitoringStatus = "Disabled"
	MonitoringStatusEnabled  MonitoringStatus = "Enabled"
)

func PossibleMonitoringStatusValues 

func PossibleMonitoringStatusValues() []MonitoringStatus

PossibleMonitoringStatusValues returns the possible values for the MonitoringStatus const type.

type MonitoringTagRulesProperties 

type MonitoringTagRulesProperties struct {
	// Set of rules for sending logs for the Monitor resource.
	LogRules *LogRules

	// Set of rules for sending metrics for the Monitor resource.
	MetricRules *MetricRules

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

MonitoringTagRulesProperties - Properties for the Tag rules resource of a Monitor account.

func (MonitoringTagRulesProperties) MarshalJSON 

func (m MonitoringTagRulesProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MonitoringTagRulesProperties.

func (*MonitoringTagRulesProperties) UnmarshalJSON 

func (m *MonitoringTagRulesProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MonitoringTagRulesProperties.

type MonitoringType 

type MonitoringType string

MonitoringType - The monitoring mode of OneAgent 

const (
	MonitoringTypeCLOUDINFRASTRUCTURE MonitoringType = "CLOUD_INFRASTRUCTURE"
	MonitoringTypeFULLSTACK           MonitoringType = "FULL_STACK"
)

func PossibleMonitoringTypeValues 

func PossibleMonitoringTypeValues() []MonitoringType

PossibleMonitoringTypeValues returns the possible values for the MonitoringType const type.

type MonitorsClient 

type MonitorsClient struct {
	// contains filtered or unexported fields
}

MonitorsClient contains the methods for the Monitors group. Don't use this type directly, use NewMonitorsClient() instead.

func NewMonitorsClient 

func NewMonitorsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*MonitorsClient, error)

NewMonitorsClient creates a new instance of MonitorsClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*MonitorsClient) BeginCreateOrUpdate 

func (client *MonitorsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, monitorName string, resource MonitorResource, options *MonitorsClientBeginCreateOrUpdateOptions) (*runtime.Poller[MonitorsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a MonitorResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • resource - Resource create parameters.
  • options - MonitorsClientBeginCreateOrUpdateOptions contains the optional parameters for the MonitorsClient.BeginCreateOrUpdate method.
Example (MonitorsCreateOrUpdateMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_CreateOrUpdate_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewMonitorsClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myMonitor", armdynatrace.MonitorResource{
	Location: to.Ptr("West US 2"),
	Tags: map[string]*string{
		"Environment": to.Ptr("Dev"),
	},
	Identity: &armdynatrace.IdentityProperties{
		Type: to.Ptr(armdynatrace.ManagedIdentityTypeSystemAssigned),
	},
	Properties: &armdynatrace.MonitorProperties{
		DynatraceEnvironmentProperties: &armdynatrace.EnvironmentProperties{
			AccountInfo:            &armdynatrace.AccountInfo{},
			EnvironmentInfo:        &armdynatrace.EnvironmentInfo{},
			SingleSignOnProperties: &armdynatrace.SingleSignOnProperties{},
		},
		LiftrResourceCategory:         to.Ptr(armdynatrace.LiftrResourceCategoriesUnknown),
		MarketplaceSubscriptionStatus: to.Ptr(armdynatrace.MarketplaceSubscriptionStatusActive),
		MonitoringStatus:              to.Ptr(armdynatrace.MonitoringStatusEnabled),
		PlanData: &armdynatrace.PlanData{
			BillingCycle:  to.Ptr("Monthly"),
			EffectiveDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-08-30T13:14:33.000Z"); return t }()),
			PlanDetails:   to.Ptr("dynatraceapitestplan"),
			UsageType:     to.Ptr("Committed"),
		},
		ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateAccepted),
		UserInfo: &armdynatrace.UserInfo{
			Country:      to.Ptr("westus2"),
			EmailAddress: to.Ptr("alice@microsoft.com"),
			FirstName:    to.Ptr("Alice"),
			LastName:     to.Ptr("Bobab"),
			PhoneNumber:  to.Ptr("123456"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MonitorResource = armdynatrace.MonitorResource{
// 	Name: to.Ptr("myMonitor"),
// 	Type: to.Ptr("Dynatrace.Observability/monitors"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/monitors/myMonitor"),
// 	Location: to.Ptr("West US 2"),
// 	Tags: map[string]*string{
// 		"Environment": to.Ptr("Dev"),
// 	},
// 	Identity: &armdynatrace.IdentityProperties{
// 		Type: to.Ptr(armdynatrace.ManagedIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("4534676867978"),
// 		TenantID: to.Ptr("23456789001"),
// 	},
// 	Properties: &armdynatrace.MonitorProperties{
// 		DynatraceEnvironmentProperties: &armdynatrace.EnvironmentProperties{
// 			AccountInfo: &armdynatrace.AccountInfo{
// 				AccountID: to.Ptr("1234567890"),
// 				RegionID: to.Ptr("wus2"),
// 			},
// 			EnvironmentInfo: &armdynatrace.EnvironmentInfo{
// 				EnvironmentID: to.Ptr("a23xcv456"),
// 				IngestionKey: to.Ptr("1234567890"),
// 				LogsIngestionEndpoint: to.Ptr("https://dynatrace.com"),
// 			},
// 			SingleSignOnProperties: &armdynatrace.SingleSignOnProperties{
// 				AADDomains: []*string{
// 					to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
// 					EnterpriseAppID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 					SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
// 					SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
// 				},
// 				UserID: to.Ptr("alice123"),
// 			},
// 			LiftrResourceCategory: to.Ptr(armdynatrace.LiftrResourceCategoriesUnknown),
// 			LiftrResourcePreference: to.Ptr[int32](28),
// 			MarketplaceSubscriptionStatus: to.Ptr(armdynatrace.MarketplaceSubscriptionStatusActive),
// 			MonitoringStatus: to.Ptr(armdynatrace.MonitoringStatusEnabled),
// 			PlanData: &armdynatrace.PlanData{
// 				BillingCycle: to.Ptr("Monthly"),
// 				EffectiveDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-08-30T13:14:33.000Z"); return t}()),
// 				PlanDetails: to.Ptr("dynatraceapitestplan"),
// 				UsageType: to.Ptr("Committed"),
// 			},
// 			ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
// 			UserInfo: &armdynatrace.UserInfo{
// 				Country: to.Ptr("westus2"),
// 				EmailAddress: to.Ptr("alice@microsoft.com"),
// 				FirstName: to.Ptr("Alice"),
// 				LastName: to.Ptr("Bobab"),
// 				PhoneNumber: to.Ptr("123456"),
// 			},
// 		},
// 		SystemData: &armdynatrace.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			CreatedBy: to.Ptr("alice@microsoft.com"),
// 			CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			LastModifiedBy: to.Ptr("alice@microsoft.com"),
// 			LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 		},
// 	}

Output:
Example (MonitorsCreateOrUpdateMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_CreateOrUpdate_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewMonitorsClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myMonitor", armdynatrace.MonitorResource{
	Location:   to.Ptr("West US 2"),
	Properties: &armdynatrace.MonitorProperties{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MonitorResource = armdynatrace.MonitorResource{
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/monitors/myMonitor"),
// 	Location: to.Ptr("West US 2"),
// 	Properties: &armdynatrace.MonitorProperties{
// 	},
// }

Output:

func (*MonitorsClient) BeginDelete 

func (client *MonitorsClient) BeginDelete(ctx context.Context, resourceGroupName string, monitorName string, options *MonitorsClientBeginDeleteOptions) (*runtime.Poller[MonitorsClientDeleteResponse], error)

BeginDelete - Delete a MonitorResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - MonitorsClientBeginDeleteOptions contains the optional parameters for the MonitorsClient.BeginDelete method.
Example (MonitorsDeleteMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_Delete_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewMonitorsClient().BeginDelete(ctx, "myResourceGroup", "myMonitor", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:
Example (MonitorsDeleteMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_Delete_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewMonitorsClient().BeginDelete(ctx, "myResourceGroup", "myMonitor", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*MonitorsClient) Get 

func (client *MonitorsClient) Get(ctx context.Context, resourceGroupName string, monitorName string, options *MonitorsClientGetOptions) (MonitorsClientGetResponse, error)

Get - Get a MonitorResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - MonitorsClientGetOptions contains the optional parameters for the MonitorsClient.Get method.
Example (MonitorsGetMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_Get_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().Get(ctx, "myResourceGroup", "myMonitor", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MonitorResource = armdynatrace.MonitorResource{
// 	Name: to.Ptr("myMonitor"),
// 	Type: to.Ptr("Dynatrace.Observability/monitors"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/monitors/myMonitor"),
// 	Location: to.Ptr("West US 2"),
// 	Tags: map[string]*string{
// 		"Environment": to.Ptr("Dev"),
// 	},
// 	Identity: &armdynatrace.IdentityProperties{
// 		Type: to.Ptr(armdynatrace.ManagedIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("4534676867978"),
// 		TenantID: to.Ptr("23456789001"),
// 	},
// 	Properties: &armdynatrace.MonitorProperties{
// 		DynatraceEnvironmentProperties: &armdynatrace.EnvironmentProperties{
// 			AccountInfo: &armdynatrace.AccountInfo{
// 				AccountID: to.Ptr("1234567890"),
// 				RegionID: to.Ptr("wus2"),
// 			},
// 			EnvironmentInfo: &armdynatrace.EnvironmentInfo{
// 				EnvironmentID: to.Ptr("a23xcv456"),
// 				IngestionKey: to.Ptr("1234567890"),
// 				LandingURL: to.Ptr("https://a23xcv456.dynatrace.com"),
// 				LogsIngestionEndpoint: to.Ptr("https://dynatrace.com"),
// 			},
// 			SingleSignOnProperties: &armdynatrace.SingleSignOnProperties{
// 				AADDomains: []*string{
// 					to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
// 					EnterpriseAppID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 					SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
// 					SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
// 				},
// 				UserID: to.Ptr("alice123"),
// 			},
// 			LiftrResourceCategory: to.Ptr(armdynatrace.LiftrResourceCategoriesUnknown),
// 			LiftrResourcePreference: to.Ptr[int32](28),
// 			MarketplaceSubscriptionStatus: to.Ptr(armdynatrace.MarketplaceSubscriptionStatusActive),
// 			MonitoringStatus: to.Ptr(armdynatrace.MonitoringStatusEnabled),
// 			PlanData: &armdynatrace.PlanData{
// 				BillingCycle: to.Ptr("Monthly"),
// 				EffectiveDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-08-30T13:14:33.000Z"); return t}()),
// 				PlanDetails: to.Ptr("dynatraceapitestplan"),
// 				UsageType: to.Ptr("Committed"),
// 			},
// 			ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
// 			UserInfo: &armdynatrace.UserInfo{
// 				Country: to.Ptr("westus2"),
// 				EmailAddress: to.Ptr("alice@microsoft.com"),
// 				FirstName: to.Ptr("Alice"),
// 				LastName: to.Ptr("Bobab"),
// 				PhoneNumber: to.Ptr("123456"),
// 			},
// 		},
// 		SystemData: &armdynatrace.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			CreatedBy: to.Ptr("alice@microsoft.com"),
// 			CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			LastModifiedBy: to.Ptr("alice@microsoft.com"),
// 			LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 		},
// 	}

Output:
Example (MonitorsGetMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_Get_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().Get(ctx, "myResourceGroup", "myMonitor", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MonitorResource = armdynatrace.MonitorResource{
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/monitors/myMonitor"),
// 	Location: to.Ptr("West US 2"),
// 	Properties: &armdynatrace.MonitorProperties{
// 	},
// }

Output:

func (*MonitorsClient) GetMarketplaceSaaSResourceDetails 

func (client *MonitorsClient) GetMarketplaceSaaSResourceDetails(ctx context.Context, request MarketplaceSaaSResourceDetailsRequest, options *MonitorsClientGetMarketplaceSaaSResourceDetailsOptions) (MonitorsClientGetMarketplaceSaaSResourceDetailsResponse, error)

GetMarketplaceSaaSResourceDetails - Get Marketplace SaaS resource details of a tenant under a specific subscription If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • request - Tenant Id
  • options - MonitorsClientGetMarketplaceSaaSResourceDetailsOptions contains the optional parameters for the MonitorsClient.GetMarketplaceSaaSResourceDetails method.
Example (MonitorsGetMarketplaceSaaSResourceDetailsMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_GetMarketplaceSaaSResourceDetails_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().GetMarketplaceSaaSResourceDetails(ctx, armdynatrace.MarketplaceSaaSResourceDetailsRequest{
	TenantID: to.Ptr("urnmattojzhktcfw"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MarketplaceSaaSResourceDetailsResponse = armdynatrace.MarketplaceSaaSResourceDetailsResponse{
// 	MarketplaceSaaSResourceID: to.Ptr("owpmulwohq"),
// 	MarketplaceSubscriptionStatus: to.Ptr(armdynatrace.MarketplaceSubscriptionStatusActive),
// 	PlanID: to.Ptr("dsfefsaf"),
// }

Output:
Example (MonitorsGetMarketplaceSaaSResourceDetailsMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_GetMarketplaceSaaSResourceDetails_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().GetMarketplaceSaaSResourceDetails(ctx, armdynatrace.MarketplaceSaaSResourceDetailsRequest{
	TenantID: to.Ptr("urnmattojzhktcfw"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MarketplaceSaaSResourceDetailsResponse = armdynatrace.MarketplaceSaaSResourceDetailsResponse{
// }

Output:

func (*MonitorsClient) GetMetricStatus 

func (client *MonitorsClient) GetMetricStatus(ctx context.Context, resourceGroupName string, monitorName string, options *MonitorsClientGetMetricStatusOptions) (MonitorsClientGetMetricStatusResponse, error)

GetMetricStatus - Get metric status If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Name of the Monitor resource
  • options - MonitorsClientGetMetricStatusOptions contains the optional parameters for the MonitorsClient.GetMetricStatus method.
Example (MonitorsGetMetricStatusMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_GetMetricStatus_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().GetMetricStatus(ctx, "rgDynatrace", "fhcjxnxumkdlgpwanewtkdnyuz", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MetricsStatusResponse = armdynatrace.MetricsStatusResponse{
// 	AzureResourceIDs: []*string{
// 		to.Ptr("/subscriptions/69b51384-146c-4685-9dab-5ae01877d78/resourceGroups/szytr-liftr/providers/Dynatrace.Observability/monitors/szytrz-prod-23-05-23")},
// 	}

Output:
Example (MonitorsGetMetricStatusMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_GetMetricStatus_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().GetMetricStatus(ctx, "rgDynatrace", "fhcjxnxumkdlgpwanewtkdnyuz", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MetricsStatusResponse = armdynatrace.MetricsStatusResponse{
// }

Output:

func (*MonitorsClient) GetSSODetails 

func (client *MonitorsClient) GetSSODetails(ctx context.Context, resourceGroupName string, monitorName string, options *MonitorsClientGetSSODetailsOptions) (MonitorsClientGetSSODetailsResponse, error)

GetSSODetails - Gets the SSO configuration details from the partner. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - MonitorsClientGetSSODetailsOptions contains the optional parameters for the MonitorsClient.GetSSODetails method.
Example (MonitorsGetSsoDetailsMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_GetSSODetails_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().GetSSODetails(ctx, "myResourceGroup", "myMonitor", &armdynatrace.MonitorsClientGetSSODetailsOptions{Request: &armdynatrace.SSODetailsRequest{
	UserPrincipal: to.Ptr("alice@microsoft.com"),
},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SSODetailsResponse = armdynatrace.SSODetailsResponse{
// 	AADDomains: []*string{
// 		to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
// 		AdminUsers: []*string{
// 			to.Ptr("alice@microsoft.com")},
// 			IsSsoEnabled: to.Ptr(armdynatrace.SSOStatusEnabled),
// 			MetadataURL: to.Ptr("https://someuri"),
// 			SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
// 		}

Output:
Example (MonitorsGetSsoDetailsMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_GetSSODetails_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().GetSSODetails(ctx, "myResourceGroup", "myMonitor", &armdynatrace.MonitorsClientGetSSODetailsOptions{Request: &armdynatrace.SSODetailsRequest{
	UserPrincipal: to.Ptr("alice@microsoft.com"),
},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SSODetailsResponse = armdynatrace.SSODetailsResponse{
// }

Output:

func (*MonitorsClient) GetVMHostPayload 

func (client *MonitorsClient) GetVMHostPayload(ctx context.Context, resourceGroupName string, monitorName string, options *MonitorsClientGetVMHostPayloadOptions) (MonitorsClientGetVMHostPayloadResponse, error)

GetVMHostPayload - Returns the payload that needs to be passed in the request body for installing Dynatrace agent on a VM. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - MonitorsClientGetVMHostPayloadOptions contains the optional parameters for the MonitorsClient.GetVMHostPayload method.
Example (MonitorsGetVmHostPayloadMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_GetVMHostPayload_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().GetVMHostPayload(ctx, "myResourceGroup", "myMonitor", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VMExtensionPayload = armdynatrace.VMExtensionPayload{
// 	EnvironmentID: to.Ptr("abc123lsjlsfjlfjgd"),
// 	IngestionKey: to.Ptr("abcd.efg"),
// }

Output:
Example (MonitorsGetVmHostPayloadMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_GetVMHostPayload_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().GetVMHostPayload(ctx, "myResourceGroup", "myMonitor", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VMExtensionPayload = armdynatrace.VMExtensionPayload{
// }

Output:

func (*MonitorsClient) NewListAppServicesPager 

func (client *MonitorsClient) NewListAppServicesPager(resourceGroupName string, monitorName string, options *MonitorsClientListAppServicesOptions) *runtime.Pager[MonitorsClientListAppServicesResponse]

NewListAppServicesPager - Gets list of App Services with Dynatrace PaaS OneAgent enabled

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - MonitorsClientListAppServicesOptions contains the optional parameters for the MonitorsClient.NewListAppServicesPager method.
Example (MonitorsListAppServicesMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListAppServices_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListAppServicesPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AppServiceListResponse = armdynatrace.AppServiceListResponse{
	// 	Value: []*armdynatrace.AppServiceInfo{
	// 		{
	// 			AutoUpdateSetting: to.Ptr(armdynatrace.AutoUpdateSettingENABLED),
	// 			AvailabilityState: to.Ptr(armdynatrace.AvailabilityStateCRASHED),
	// 			HostGroup: to.Ptr("myGroup"),
	// 			HostName: to.Ptr("myName"),
	// 			LogModule: to.Ptr(armdynatrace.LogModuleENABLED),
	// 			MonitoringType: to.Ptr(armdynatrace.MonitoringTypeCLOUDINFRASTRUCTURE),
	// 			ResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/virtual1"),
	// 			UpdateStatus: to.Ptr(armdynatrace.UpdateStatusINCOMPATIBLE),
	// 			Version: to.Ptr("1.2.0"),
	// 	}},
	// }
}

Output:
Example (MonitorsListAppServicesMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListAppServices_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListAppServicesPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AppServiceListResponse = armdynatrace.AppServiceListResponse{
	// }
}

Output:

func (*MonitorsClient) NewListByResourceGroupPager 

func (client *MonitorsClient) NewListByResourceGroupPager(resourceGroupName string, options *MonitorsClientListByResourceGroupOptions) *runtime.Pager[MonitorsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List MonitorResource resources by resource group

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - MonitorsClientListByResourceGroupOptions contains the optional parameters for the MonitorsClient.NewListByResourceGroupPager method.
Example (MonitorsListByResourceGroupMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListByResourceGroup_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListByResourceGroupPager("myResourceGroup", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.MonitorResourceListResult = armdynatrace.MonitorResourceListResult{
	// 	Value: []*armdynatrace.MonitorResource{
	// 		{
	// 			Name: to.Ptr("myMonitor"),
	// 			Type: to.Ptr("Dynatrace.Observability/monitors"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/monitors/myMonitor"),
	// 			Location: to.Ptr("West US 2"),
	// 			Tags: map[string]*string{
	// 				"Environment": to.Ptr("Dev"),
	// 			},
	// 			Identity: &armdynatrace.IdentityProperties{
	// 				Type: to.Ptr(armdynatrace.ManagedIdentityTypeSystemAssigned),
	// 				PrincipalID: to.Ptr("4534676867978"),
	// 				TenantID: to.Ptr("23456789001"),
	// 			},
	// 			Properties: &armdynatrace.MonitorProperties{
	// 				DynatraceEnvironmentProperties: &armdynatrace.EnvironmentProperties{
	// 					AccountInfo: &armdynatrace.AccountInfo{
	// 						AccountID: to.Ptr("1234567890"),
	// 						RegionID: to.Ptr("wus2"),
	// 					},
	// 					EnvironmentInfo: &armdynatrace.EnvironmentInfo{
	// 						EnvironmentID: to.Ptr("a23xcv456"),
	// 						IngestionKey: to.Ptr("1234567890"),
	// 						LandingURL: to.Ptr("https://a23xcv456.dynatrace.com"),
	// 						LogsIngestionEndpoint: to.Ptr("https://dynatrace.com"),
	// 					},
	// 					SingleSignOnProperties: &armdynatrace.SingleSignOnProperties{
	// 						AADDomains: []*string{
	// 							to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
	// 							EnterpriseAppID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 							SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
	// 							SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
	// 						},
	// 						UserID: to.Ptr("alice123"),
	// 					},
	// 					LiftrResourceCategory: to.Ptr(armdynatrace.LiftrResourceCategoriesUnknown),
	// 					LiftrResourcePreference: to.Ptr[int32](28),
	// 					MarketplaceSubscriptionStatus: to.Ptr(armdynatrace.MarketplaceSubscriptionStatusActive),
	// 					MonitoringStatus: to.Ptr(armdynatrace.MonitoringStatusEnabled),
	// 					PlanData: &armdynatrace.PlanData{
	// 						BillingCycle: to.Ptr("Monthly"),
	// 						EffectiveDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-08-30T13:14:33.000Z"); return t}()),
	// 						PlanDetails: to.Ptr("dynatraceapitestplan"),
	// 						UsageType: to.Ptr("Committed"),
	// 					},
	// 					ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
	// 					UserInfo: &armdynatrace.UserInfo{
	// 						Country: to.Ptr("westus2"),
	// 						EmailAddress: to.Ptr("alice@microsoft.com"),
	// 						FirstName: to.Ptr("Alice"),
	// 						LastName: to.Ptr("Bobab"),
	// 						PhoneNumber: to.Ptr("123456"),
	// 					},
	// 				},
	// 				SystemData: &armdynatrace.SystemData{
	// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
	// 					CreatedBy: to.Ptr("alice@microsoft.com"),
	// 					CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
	// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
	// 					LastModifiedBy: to.Ptr("alice@microsoft.com"),
	// 					LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
	// 				},
	// 		}},
	// 	}
}

Output:
Example (MonitorsListByResourceGroupMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListByResourceGroup_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListByResourceGroupPager("myResourceGroup", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.MonitorResourceListResult = armdynatrace.MonitorResourceListResult{
	// 	Value: []*armdynatrace.MonitorResource{
	// 		{
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/tagRules/default"),
	// 			Location: to.Ptr("West US 2"),
	// 			Properties: &armdynatrace.MonitorProperties{
	// 			},
	// 	}},
	// }
}

Output:

func (*MonitorsClient) NewListBySubscriptionIDPager 

func (client *MonitorsClient) NewListBySubscriptionIDPager(options *MonitorsClientListBySubscriptionIDOptions) *runtime.Pager[MonitorsClientListBySubscriptionIDResponse]

NewListBySubscriptionIDPager - List all MonitorResource by subscriptionId

Generated from API version 2023-04-27

  • options - MonitorsClientListBySubscriptionIDOptions contains the optional parameters for the MonitorsClient.NewListBySubscriptionIDPager method.
Example (MonitorsListBySubscriptionIdMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListBySubscriptionId_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListBySubscriptionIDPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.MonitorResourceListResult = armdynatrace.MonitorResourceListResult{
	// 	Value: []*armdynatrace.MonitorResource{
	// 		{
	// 			Name: to.Ptr("myMonitor"),
	// 			Type: to.Ptr("Dynatrace.Observability/monitors"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/monitors/myMonitor"),
	// 			Location: to.Ptr("West US 2"),
	// 			Tags: map[string]*string{
	// 				"Environment": to.Ptr("Dev"),
	// 			},
	// 			Identity: &armdynatrace.IdentityProperties{
	// 				Type: to.Ptr(armdynatrace.ManagedIdentityTypeSystemAssigned),
	// 				PrincipalID: to.Ptr("4534676867978"),
	// 				TenantID: to.Ptr("23456789001"),
	// 			},
	// 			Properties: &armdynatrace.MonitorProperties{
	// 				DynatraceEnvironmentProperties: &armdynatrace.EnvironmentProperties{
	// 					AccountInfo: &armdynatrace.AccountInfo{
	// 						AccountID: to.Ptr("1234567890"),
	// 						RegionID: to.Ptr("wus2"),
	// 					},
	// 					EnvironmentInfo: &armdynatrace.EnvironmentInfo{
	// 						EnvironmentID: to.Ptr("a23xcv456"),
	// 						IngestionKey: to.Ptr("1234567890"),
	// 						LandingURL: to.Ptr("https://a23xcv456.dynatrace.com"),
	// 						LogsIngestionEndpoint: to.Ptr("https://dynatrace.com"),
	// 					},
	// 					SingleSignOnProperties: &armdynatrace.SingleSignOnProperties{
	// 						AADDomains: []*string{
	// 							to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
	// 							EnterpriseAppID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 							SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
	// 							SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
	// 						},
	// 						UserID: to.Ptr("alice123"),
	// 					},
	// 					LiftrResourceCategory: to.Ptr(armdynatrace.LiftrResourceCategoriesUnknown),
	// 					LiftrResourcePreference: to.Ptr[int32](28),
	// 					MarketplaceSubscriptionStatus: to.Ptr(armdynatrace.MarketplaceSubscriptionStatusActive),
	// 					MonitoringStatus: to.Ptr(armdynatrace.MonitoringStatusEnabled),
	// 					PlanData: &armdynatrace.PlanData{
	// 						BillingCycle: to.Ptr("Monthly"),
	// 						EffectiveDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-08-30T13:14:33.000Z"); return t}()),
	// 						PlanDetails: to.Ptr("dynatraceapitestplan"),
	// 						UsageType: to.Ptr("Committed"),
	// 					},
	// 					ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
	// 					UserInfo: &armdynatrace.UserInfo{
	// 						Country: to.Ptr("westus2"),
	// 						EmailAddress: to.Ptr("alice@microsoft.com"),
	// 						FirstName: to.Ptr("Alice"),
	// 						LastName: to.Ptr("Bobab"),
	// 						PhoneNumber: to.Ptr("123456"),
	// 					},
	// 				},
	// 				SystemData: &armdynatrace.SystemData{
	// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
	// 					CreatedBy: to.Ptr("alice@microsoft.com"),
	// 					CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
	// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
	// 					LastModifiedBy: to.Ptr("alice@microsoft.com"),
	// 					LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
	// 				},
	// 		}},
	// 	}
}

Output:
Example (MonitorsListBySubscriptionIdMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListBySubscriptionId_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListBySubscriptionIDPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.MonitorResourceListResult = armdynatrace.MonitorResourceListResult{
	// 	Value: []*armdynatrace.MonitorResource{
	// 		{
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/tagRules/default"),
	// 			Location: to.Ptr("West US 2"),
	// 			Properties: &armdynatrace.MonitorProperties{
	// 			},
	// 	}},
	// }
}

Output:

func (*MonitorsClient) NewListHostsPager 

func (client *MonitorsClient) NewListHostsPager(resourceGroupName string, monitorName string, options *MonitorsClientListHostsOptions) *runtime.Pager[MonitorsClientListHostsResponse]

NewListHostsPager - List the VM/VMSS resources currently being monitored by the Dynatrace resource.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - MonitorsClientListHostsOptions contains the optional parameters for the MonitorsClient.NewListHostsPager method.
Example (MonitorsListHostsMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListHosts_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListHostsPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.VMHostsListResponse = armdynatrace.VMHostsListResponse{
	// 	Value: []*armdynatrace.VMInfo{
	// 		{
	// 			AutoUpdateSetting: to.Ptr(armdynatrace.AutoUpdateSettingENABLED),
	// 			AvailabilityState: to.Ptr(armdynatrace.AvailabilityStateCRASHED),
	// 			HostGroup: to.Ptr("myGroup"),
	// 			HostName: to.Ptr("myName"),
	// 			LogModule: to.Ptr(armdynatrace.LogModuleENABLED),
	// 			MonitoringType: to.Ptr(armdynatrace.MonitoringTypeCLOUDINFRASTRUCTURE),
	// 			ResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/virtual1"),
	// 			UpdateStatus: to.Ptr(armdynatrace.UpdateStatusINCOMPATIBLE),
	// 			Version: to.Ptr("1.2.0"),
	// 	}},
	// }
}

Output:
Example (MonitorsListHostsMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListHosts_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListHostsPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.VMHostsListResponse = armdynatrace.VMHostsListResponse{
	// }
}

Output:

func (*MonitorsClient) NewListLinkableEnvironmentsPager 

func (client *MonitorsClient) NewListLinkableEnvironmentsPager(resourceGroupName string, monitorName string, request LinkableEnvironmentRequest, options *MonitorsClientListLinkableEnvironmentsOptions) *runtime.Pager[MonitorsClientListLinkableEnvironmentsResponse]

NewListLinkableEnvironmentsPager - Gets all the Dynatrace environments that a user can link a azure resource to

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • request - The details of the linkable environment request.
  • options - MonitorsClientListLinkableEnvironmentsOptions contains the optional parameters for the MonitorsClient.NewListLinkableEnvironmentsPager method.
Example (MonitorsListLinkableEnvironmentsMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListLinkableEnvironments_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListLinkableEnvironmentsPager("myResourceGroup", "myMonitor", armdynatrace.LinkableEnvironmentRequest{
	Region:        to.Ptr("East US"),
	TenantID:      to.Ptr("00000000-0000-0000-0000-000000000000"),
	UserPrincipal: to.Ptr("alice@microsoft.com"),
}, nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.LinkableEnvironmentListResponse = armdynatrace.LinkableEnvironmentListResponse{
	// 	Value: []*armdynatrace.LinkableEnvironmentResponse{
	// 		{
	// 			EnvironmentID: to.Ptr("abc.123"),
	// 			EnvironmentName: to.Ptr("myEnv"),
	// 			PlanData: &armdynatrace.PlanData{
	// 				BillingCycle: to.Ptr("Monthly"),
	// 				EffectiveDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-08-30T13:14:33.000Z"); return t}()),
	// 				PlanDetails: to.Ptr("dynatraceapitestplan"),
	// 				UsageType: to.Ptr("Committed"),
	// 			},
	// 	}},
	// }
}

Output:
Example (MonitorsListLinkableEnvironmentsMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListLinkableEnvironments_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListLinkableEnvironmentsPager("myResourceGroup", "myMonitor", armdynatrace.LinkableEnvironmentRequest{
	Region:        to.Ptr("East US"),
	TenantID:      to.Ptr("00000000-0000-0000-0000-000000000000"),
	UserPrincipal: to.Ptr("alice@microsoft.com"),
}, nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.LinkableEnvironmentListResponse = armdynatrace.LinkableEnvironmentListResponse{
	// }
}

Output:

func (*MonitorsClient) NewListMonitoredResourcesPager 

func (client *MonitorsClient) NewListMonitoredResourcesPager(resourceGroupName string, monitorName string, options *MonitorsClientListMonitoredResourcesOptions) *runtime.Pager[MonitorsClientListMonitoredResourcesResponse]

NewListMonitoredResourcesPager - List the resources currently being monitored by the Dynatrace monitor resource.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - MonitorsClientListMonitoredResourcesOptions contains the optional parameters for the MonitorsClient.NewListMonitoredResourcesPager method.
Example (MonitorsListMonitoredResourcesMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListMonitoredResources_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListMonitoredResourcesPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.MonitoredResourceListResponse = armdynatrace.MonitoredResourceListResponse{
	// 	Value: []*armdynatrace.MonitoredResource{
	// 		{
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/monitors/myMonitor/listMonitoredResources"),
	// 			ReasonForLogsStatus: to.Ptr("CapturedByRules"),
	// 			ReasonForMetricsStatus: to.Ptr("CapturedByRules"),
	// 			SendingLogs: to.Ptr(armdynatrace.SendingLogsStatusEnabled),
	// 			SendingMetrics: to.Ptr(armdynatrace.SendingMetricsStatusEnabled),
	// 	}},
	// }
}

Output:
Example (MonitorsListMonitoredResourcesMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_ListMonitoredResources_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMonitorsClient().NewListMonitoredResourcesPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.MonitoredResourceListResponse = armdynatrace.MonitoredResourceListResponse{
	// }
}

Output:

func (*MonitorsClient) Update 

func (client *MonitorsClient) Update(ctx context.Context, resourceGroupName string, monitorName string, resource MonitorResourceUpdate, options *MonitorsClientUpdateOptions) (MonitorsClientUpdateResponse, error)

Update - Update a MonitorResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • resource - The resource properties to be updated.
  • options - MonitorsClientUpdateOptions contains the optional parameters for the MonitorsClient.Update method.
Example (MonitorsUpdateMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_Update_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().Update(ctx, "myResourceGroup", "myMonitor", armdynatrace.MonitorResourceUpdate{
	Tags: map[string]*string{
		"Environment": to.Ptr("Dev"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MonitorResource = armdynatrace.MonitorResource{
// 	Name: to.Ptr("myMonitor"),
// 	Type: to.Ptr("Dynatrace.Observability/monitors"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/monitors/myMonitor"),
// 	Location: to.Ptr("West US 2"),
// 	Tags: map[string]*string{
// 		"Environment": to.Ptr("Dev"),
// 	},
// 	Identity: &armdynatrace.IdentityProperties{
// 		Type: to.Ptr(armdynatrace.ManagedIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("4534676867978"),
// 		TenantID: to.Ptr("23456789001"),
// 	},
// 	Properties: &armdynatrace.MonitorProperties{
// 		DynatraceEnvironmentProperties: &armdynatrace.EnvironmentProperties{
// 			AccountInfo: &armdynatrace.AccountInfo{
// 				AccountID: to.Ptr("1234567890"),
// 				RegionID: to.Ptr("wus2"),
// 			},
// 			EnvironmentInfo: &armdynatrace.EnvironmentInfo{
// 				EnvironmentID: to.Ptr("a23xcv456"),
// 				IngestionKey: to.Ptr("1234567890"),
// 				LandingURL: to.Ptr("https://a23xcv456.dynatrace.com"),
// 				LogsIngestionEndpoint: to.Ptr("https://dynatrace.com"),
// 			},
// 			SingleSignOnProperties: &armdynatrace.SingleSignOnProperties{
// 				AADDomains: []*string{
// 					to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
// 					EnterpriseAppID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 					SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
// 					SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
// 				},
// 				UserID: to.Ptr("alice123"),
// 			},
// 			LiftrResourceCategory: to.Ptr(armdynatrace.LiftrResourceCategoriesUnknown),
// 			LiftrResourcePreference: to.Ptr[int32](28),
// 			MarketplaceSubscriptionStatus: to.Ptr(armdynatrace.MarketplaceSubscriptionStatusActive),
// 			MonitoringStatus: to.Ptr(armdynatrace.MonitoringStatusEnabled),
// 			PlanData: &armdynatrace.PlanData{
// 				BillingCycle: to.Ptr("Monthly"),
// 				EffectiveDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-08-30T13:14:33.000Z"); return t}()),
// 				PlanDetails: to.Ptr("dynatraceapitestplan"),
// 				UsageType: to.Ptr("Committed"),
// 			},
// 			ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
// 			UserInfo: &armdynatrace.UserInfo{
// 				Country: to.Ptr("westus2"),
// 				EmailAddress: to.Ptr("alice@microsoft.com"),
// 				FirstName: to.Ptr("Alice"),
// 				LastName: to.Ptr("Bobab"),
// 				PhoneNumber: to.Ptr("123456"),
// 			},
// 		},
// 		SystemData: &armdynatrace.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			CreatedBy: to.Ptr("alice@microsoft.com"),
// 			CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			LastModifiedBy: to.Ptr("alice@microsoft.com"),
// 			LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 		},
// 	}

Output:
Example (MonitorsUpdateMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Monitors_Update_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMonitorsClient().Update(ctx, "myResourceGroup", "myMonitor", armdynatrace.MonitorResourceUpdate{}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.MonitorResource = armdynatrace.MonitorResource{
// 	Location: to.Ptr("West US 2"),
// 	Properties: &armdynatrace.MonitorProperties{
// 	},
// }

Output:

type MonitorsClientBeginCreateOrUpdateOptions 

type MonitorsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

MonitorsClientBeginCreateOrUpdateOptions contains the optional parameters for the MonitorsClient.BeginCreateOrUpdate method.

type MonitorsClientBeginDeleteOptions 

type MonitorsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

MonitorsClientBeginDeleteOptions contains the optional parameters for the MonitorsClient.BeginDelete method.

type MonitorsClientCreateOrUpdateResponse 

type MonitorsClientCreateOrUpdateResponse struct {
	// Dynatrace Monitor Resource
	MonitorResource
}

MonitorsClientCreateOrUpdateResponse contains the response from method MonitorsClient.BeginCreateOrUpdate.

type MonitorsClientDeleteResponse 

type MonitorsClientDeleteResponse struct {
}

MonitorsClientDeleteResponse contains the response from method MonitorsClient.BeginDelete.

type MonitorsClientGetMarketplaceSaaSResourceDetailsOptions 

type MonitorsClientGetMarketplaceSaaSResourceDetailsOptions struct {
}

MonitorsClientGetMarketplaceSaaSResourceDetailsOptions contains the optional parameters for the MonitorsClient.GetMarketplaceSaaSResourceDetails method.

type MonitorsClientGetMarketplaceSaaSResourceDetailsResponse 

type MonitorsClientGetMarketplaceSaaSResourceDetailsResponse struct {
	// Marketplace SaaS resource details linked to the given tenant Id
	MarketplaceSaaSResourceDetailsResponse
}

MonitorsClientGetMarketplaceSaaSResourceDetailsResponse contains the response from method MonitorsClient.GetMarketplaceSaaSResourceDetails.

type MonitorsClientGetMetricStatusOptions 

type MonitorsClientGetMetricStatusOptions struct {
}

MonitorsClientGetMetricStatusOptions contains the optional parameters for the MonitorsClient.GetMetricStatus method.

type MonitorsClientGetMetricStatusResponse 

type MonitorsClientGetMetricStatusResponse struct {
	// Response of get metrics status operation
	MetricsStatusResponse
}

MonitorsClientGetMetricStatusResponse contains the response from method MonitorsClient.GetMetricStatus.

type MonitorsClientGetOptions 

type MonitorsClientGetOptions struct {
}

MonitorsClientGetOptions contains the optional parameters for the MonitorsClient.Get method.

type MonitorsClientGetResponse 

type MonitorsClientGetResponse struct {
	// Dynatrace Monitor Resource
	MonitorResource
}

MonitorsClientGetResponse contains the response from method MonitorsClient.Get.

type MonitorsClientGetSSODetailsOptions 

type MonitorsClientGetSSODetailsOptions struct {
	// The details of the get sso details request.
	Request *SSODetailsRequest
}

MonitorsClientGetSSODetailsOptions contains the optional parameters for the MonitorsClient.GetSSODetails method.

type MonitorsClientGetSSODetailsResponse 

type MonitorsClientGetSSODetailsResponse struct {
	// SSO details from the Dynatrace partner
	SSODetailsResponse
}

MonitorsClientGetSSODetailsResponse contains the response from method MonitorsClient.GetSSODetails.

type MonitorsClientGetVMHostPayloadOptions 

type MonitorsClientGetVMHostPayloadOptions struct {
}

MonitorsClientGetVMHostPayloadOptions contains the optional parameters for the MonitorsClient.GetVMHostPayload method.

type MonitorsClientGetVMHostPayloadResponse 

type MonitorsClientGetVMHostPayloadResponse struct {
	// Response of payload to be passed while installing VM agent.
	VMExtensionPayload
}

MonitorsClientGetVMHostPayloadResponse contains the response from method MonitorsClient.GetVMHostPayload.

type MonitorsClientListAppServicesOptions 

type MonitorsClientListAppServicesOptions struct {
}

MonitorsClientListAppServicesOptions contains the optional parameters for the MonitorsClient.NewListAppServicesPager method.

type MonitorsClientListAppServicesResponse 

type MonitorsClientListAppServicesResponse struct {
	// Response of a list App Services Operation.
	AppServiceListResponse
}

MonitorsClientListAppServicesResponse contains the response from method MonitorsClient.NewListAppServicesPager.

type MonitorsClientListByResourceGroupOptions 

type MonitorsClientListByResourceGroupOptions struct {
}

MonitorsClientListByResourceGroupOptions contains the optional parameters for the MonitorsClient.NewListByResourceGroupPager method.

type MonitorsClientListByResourceGroupResponse 

type MonitorsClientListByResourceGroupResponse struct {
	// The response of a MonitorResource list operation.
	MonitorResourceListResult
}

MonitorsClientListByResourceGroupResponse contains the response from method MonitorsClient.NewListByResourceGroupPager.

type MonitorsClientListBySubscriptionIDOptions 

type MonitorsClientListBySubscriptionIDOptions struct {
}

MonitorsClientListBySubscriptionIDOptions contains the optional parameters for the MonitorsClient.NewListBySubscriptionIDPager method.

type MonitorsClientListBySubscriptionIDResponse 

type MonitorsClientListBySubscriptionIDResponse struct {
	// The response of a MonitorResource list operation.
	MonitorResourceListResult
}

MonitorsClientListBySubscriptionIDResponse contains the response from method MonitorsClient.NewListBySubscriptionIDPager.

type MonitorsClientListHostsOptions 

type MonitorsClientListHostsOptions struct {
}

MonitorsClientListHostsOptions contains the optional parameters for the MonitorsClient.NewListHostsPager method.

type MonitorsClientListHostsResponse 

type MonitorsClientListHostsResponse struct {
	// Response of a list VM Host Operation.
	VMHostsListResponse
}

MonitorsClientListHostsResponse contains the response from method MonitorsClient.NewListHostsPager.

type MonitorsClientListLinkableEnvironmentsOptions 

type MonitorsClientListLinkableEnvironmentsOptions struct {
}

MonitorsClientListLinkableEnvironmentsOptions contains the optional parameters for the MonitorsClient.NewListLinkableEnvironmentsPager method.

type MonitorsClientListLinkableEnvironmentsResponse 

type MonitorsClientListLinkableEnvironmentsResponse struct {
	// Response for getting all the linkable environments
	LinkableEnvironmentListResponse
}

MonitorsClientListLinkableEnvironmentsResponse contains the response from method MonitorsClient.NewListLinkableEnvironmentsPager.

type MonitorsClientListMonitoredResourcesOptions 

type MonitorsClientListMonitoredResourcesOptions struct {
}

MonitorsClientListMonitoredResourcesOptions contains the optional parameters for the MonitorsClient.NewListMonitoredResourcesPager method.

type MonitorsClientListMonitoredResourcesResponse 

type MonitorsClientListMonitoredResourcesResponse struct {
	// List of all the resources being monitored by Dynatrace monitor resource
	MonitoredResourceListResponse
}

MonitorsClientListMonitoredResourcesResponse contains the response from method MonitorsClient.NewListMonitoredResourcesPager.

type MonitorsClientUpdateOptions 

type MonitorsClientUpdateOptions struct {
}

MonitorsClientUpdateOptions contains the optional parameters for the MonitorsClient.Update method.

type MonitorsClientUpdateResponse 

type MonitorsClientUpdateResponse struct {
	// Dynatrace Monitor Resource
	MonitorResource
}

MonitorsClientUpdateResponse contains the response from method MonitorsClient.Update.

type Operation 

type Operation struct {
	// Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for ARM/control-plane
	// operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - Details of a REST API operation, returned from the Resource Provider Operations API

func (Operation) MarshalJSON 

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

func (o *Operation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for this particular operation.

func (OperationDisplay) MarshalJSON 

func (o OperationDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

func (o *OperationDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; URL to get the next set of operation list results (if there are any).
	NextLink *string

	// READ-ONLY; List of operations supported by the resource provider
	Value []*Operation
}

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationsClient 

type OperationsClient struct {
	// contains filtered or unexported fields
}

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) NewListPager 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - List the operations for Dynatrace.Observability

Generated from API version 2023-04-27

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
Example (OperationsListMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Operations_List_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOperationsClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.OperationListResult = armdynatrace.OperationListResult{
	// 	Value: []*armdynatrace.Operation{
	// 		{
	// 			Name: to.Ptr("Dynatrace.Observability/monitors/write"),
	// 			ActionType: to.Ptr(armdynatrace.ActionTypeInternal),
	// 			Display: &armdynatrace.OperationDisplay{
	// 				Description: to.Ptr("Write monitors resource"),
	// 				Operation: to.Ptr("write"),
	// 				Provider: to.Ptr("Dynatrace.Observability"),
	// 				Resource: to.Ptr("monitors"),
	// 			},
	// 			IsDataAction: to.Ptr(true),
	// 			Origin: to.Ptr(armdynatrace.OriginUser),
	// 	}},
	// }
}

Output:
Example (OperationsListMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/Operations_List_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOperationsClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.OperationListResult = armdynatrace.OperationListResult{
	// }
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type Origin 

type Origin string

Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" 

const (
	OriginSystem     Origin = "system"
	OriginUser       Origin = "user"
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PlanData 

type PlanData struct {
	// different billing cycles like MONTHLY/WEEKLY. this could be enum
	BillingCycle *string

	// date when plan was applied
	EffectiveDate *time.Time

	// plan id as published by Dynatrace
	PlanDetails *string

	// different usage type like PAYG/COMMITTED. this could be enum
	UsageType *string
}

PlanData - Billing plan information.

func (PlanData) MarshalJSON 

func (p PlanData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlanData.

func (*PlanData) UnmarshalJSON 

func (p *PlanData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlanData.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - Provisioning state of the monitoring resource 

const (
	ProvisioningStateAccepted     ProvisioningState = "Accepted"
	ProvisioningStateCanceled     ProvisioningState = "Canceled"
	ProvisioningStateCreating     ProvisioningState = "Creating"
	ProvisioningStateDeleted      ProvisioningState = "Deleted"
	ProvisioningStateDeleting     ProvisioningState = "Deleting"
	ProvisioningStateFailed       ProvisioningState = "Failed"
	ProvisioningStateNotSpecified ProvisioningState = "NotSpecified"
	ProvisioningStateSucceeded    ProvisioningState = "Succeeded"
	ProvisioningStateUpdating     ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type SSODetailsRequest 

type SSODetailsRequest struct {
	// REQUIRED; user principal id of the user
	UserPrincipal *string
}

SSODetailsRequest - Request for getting sso details for a user

func (SSODetailsRequest) MarshalJSON 

func (s SSODetailsRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SSODetailsRequest.

func (*SSODetailsRequest) UnmarshalJSON 

func (s *SSODetailsRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SSODetailsRequest.

type SSODetailsResponse 

type SSODetailsResponse struct {
	// array of Aad(azure active directory) domains
	AADDomains []*string

	// Array of admin user emails.
	AdminUsers []*string

	// Whether the SSO is enabled for this resource or not.
	IsSsoEnabled *SSOStatus

	// URL for Azure AD metadata
	MetadataURL *string

	// The login URL specific to this Dynatrace Environment
	SingleSignOnURL *string
}

SSODetailsResponse - SSO details from the Dynatrace partner

func (SSODetailsResponse) MarshalJSON 

func (s SSODetailsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SSODetailsResponse.

func (*SSODetailsResponse) UnmarshalJSON 

func (s *SSODetailsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SSODetailsResponse.

type SSOStatus 

type SSOStatus string

SSOStatus - Indicates whether SSO is enabled or not 

const (
	SSOStatusDisabled SSOStatus = "Disabled"
	SSOStatusEnabled  SSOStatus = "Enabled"
)

func PossibleSSOStatusValues 

func PossibleSSOStatusValues() []SSOStatus

PossibleSSOStatusValues returns the possible values for the SSOStatus const type.

type SendAADLogsStatus 

type SendAADLogsStatus string

SendAADLogsStatus - Indicates whether AAD logs are being sent. 

const (
	SendAADLogsStatusDisabled SendAADLogsStatus = "Disabled"
	SendAADLogsStatusEnabled  SendAADLogsStatus = "Enabled"
)

func PossibleSendAADLogsStatusValues 

func PossibleSendAADLogsStatusValues() []SendAADLogsStatus

PossibleSendAADLogsStatusValues returns the possible values for the SendAADLogsStatus const type.

type SendActivityLogsStatus 

type SendActivityLogsStatus string

SendActivityLogsStatus - Indicates whether activity logs are being sent. 

const (
	SendActivityLogsStatusDisabled SendActivityLogsStatus = "Disabled"
	SendActivityLogsStatusEnabled  SendActivityLogsStatus = "Enabled"
)

func PossibleSendActivityLogsStatusValues 

func PossibleSendActivityLogsStatusValues() []SendActivityLogsStatus

PossibleSendActivityLogsStatusValues returns the possible values for the SendActivityLogsStatus const type.

type SendSubscriptionLogsStatus 

type SendSubscriptionLogsStatus string

SendSubscriptionLogsStatus - Indicates whether subscription logs are being sent. 

const (
	SendSubscriptionLogsStatusDisabled SendSubscriptionLogsStatus = "Disabled"
	SendSubscriptionLogsStatusEnabled  SendSubscriptionLogsStatus = "Enabled"
)

func PossibleSendSubscriptionLogsStatusValues 

func PossibleSendSubscriptionLogsStatusValues() []SendSubscriptionLogsStatus

PossibleSendSubscriptionLogsStatusValues returns the possible values for the SendSubscriptionLogsStatus const type.

type SendingLogsStatus 

type SendingLogsStatus string

SendingLogsStatus - Indicates whether logs are being sent. 

const (
	SendingLogsStatusDisabled SendingLogsStatus = "Disabled"
	SendingLogsStatusEnabled  SendingLogsStatus = "Enabled"
)

func PossibleSendingLogsStatusValues 

func PossibleSendingLogsStatusValues() []SendingLogsStatus

PossibleSendingLogsStatusValues returns the possible values for the SendingLogsStatus const type.

type SendingMetricsStatus 

type SendingMetricsStatus string

SendingMetricsStatus - Indicates whether metrics are being sent. 

const (
	SendingMetricsStatusDisabled SendingMetricsStatus = "Disabled"
	SendingMetricsStatusEnabled  SendingMetricsStatus = "Enabled"
)

func PossibleSendingMetricsStatusValues 

func PossibleSendingMetricsStatusValues() []SendingMetricsStatus

PossibleSendingMetricsStatusValues returns the possible values for the SendingMetricsStatus const type.

type SingleSignOnClient 

type SingleSignOnClient struct {
	// contains filtered or unexported fields
}

SingleSignOnClient contains the methods for the SingleSignOn group. Don't use this type directly, use NewSingleSignOnClient() instead.

func NewSingleSignOnClient 

func NewSingleSignOnClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SingleSignOnClient, error)

NewSingleSignOnClient creates a new instance of SingleSignOnClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SingleSignOnClient) BeginCreateOrUpdate 

func (client *SingleSignOnClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, monitorName string, configurationName string, resource SingleSignOnResource, options *SingleSignOnClientBeginCreateOrUpdateOptions) (*runtime.Poller[SingleSignOnClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a DynatraceSingleSignOnResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • configurationName - Single Sign On Configuration Name
  • resource - Resource create parameters.
  • options - SingleSignOnClientBeginCreateOrUpdateOptions contains the optional parameters for the SingleSignOnClient.BeginCreateOrUpdate method.
Example (SingleSignOnCreateOrUpdateMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/SingleSignOn_CreateOrUpdate_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSingleSignOnClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myMonitor", "default", armdynatrace.SingleSignOnResource{
	Properties: &armdynatrace.SingleSignOnProperties{
		AADDomains: []*string{
			to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
		EnterpriseAppID:   to.Ptr("00000000-0000-0000-0000-000000000000"),
		ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateAccepted),
		SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
		SingleSignOnURL:   to.Ptr("https://www.dynatrace.io"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SingleSignOnResource = armdynatrace.SingleSignOnResource{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Dynatrace.Observability/monitors"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/singleSignOnConfigurations/default"),
// 	Properties: &armdynatrace.SingleSignOnProperties{
// 		AADDomains: []*string{
// 			to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
// 			EnterpriseAppID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 			ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
// 			SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
// 			SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
// 		},
// 		SystemData: &armdynatrace.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			CreatedBy: to.Ptr("alice@microsoft.com"),
// 			CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			LastModifiedBy: to.Ptr("alice@microsoft.com"),
// 			LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 		},
// 	}

Output:
Example (SingleSignOnCreateOrUpdateMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/SingleSignOn_CreateOrUpdate_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSingleSignOnClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myMonitor", "default", armdynatrace.SingleSignOnResource{
	Properties: &armdynatrace.SingleSignOnProperties{
		AADDomains: []*string{
			to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
		SingleSignOnURL: to.Ptr("https://www.dynatrace.io"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SingleSignOnResource = armdynatrace.SingleSignOnResource{
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/singleSignOnConfigurations/default"),
// 	Properties: &armdynatrace.SingleSignOnProperties{
// 		AADDomains: []*string{
// 			to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
// 			SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
// 		},
// 	}

Output:

func (*SingleSignOnClient) Get 

func (client *SingleSignOnClient) Get(ctx context.Context, resourceGroupName string, monitorName string, configurationName string, options *SingleSignOnClientGetOptions) (SingleSignOnClientGetResponse, error)

Get - Get a DynatraceSingleSignOnResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • configurationName - Single Sign On Configuration Name
  • options - SingleSignOnClientGetOptions contains the optional parameters for the SingleSignOnClient.Get method.
Example (SingleSignOnGetMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/SingleSignOn_Get_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSingleSignOnClient().Get(ctx, "myResourceGroup", "myMonitor", "default", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SingleSignOnResource = armdynatrace.SingleSignOnResource{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Dynatrace.Observability/monitors"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/singleSignOnConfigurations/default"),
// 	Properties: &armdynatrace.SingleSignOnProperties{
// 		AADDomains: []*string{
// 			to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
// 			EnterpriseAppID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 			ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
// 			SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
// 			SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
// 		},
// 		SystemData: &armdynatrace.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			CreatedBy: to.Ptr("alice@microsoft.com"),
// 			CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 			LastModifiedBy: to.Ptr("alice@microsoft.com"),
// 			LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 		},
// 	}

Output:
Example (SingleSignOnGetMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/SingleSignOn_Get_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSingleSignOnClient().Get(ctx, "myResourceGroup", "myMonitor", "default", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SingleSignOnResource = armdynatrace.SingleSignOnResource{
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/singleSignOnConfigurations/default"),
// 	Properties: &armdynatrace.SingleSignOnProperties{
// 		AADDomains: []*string{
// 			to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
// 			SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
// 		},
// 	}

Output:

func (*SingleSignOnClient) NewListPager 

func (client *SingleSignOnClient) NewListPager(resourceGroupName string, monitorName string, options *SingleSignOnClientListOptions) *runtime.Pager[SingleSignOnClientListResponse]

NewListPager - List all DynatraceSingleSignOnResource by monitorName

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - SingleSignOnClientListOptions contains the optional parameters for the SingleSignOnClient.NewListPager method.
Example (SingleSignOnListMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/SingleSignOn_List_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSingleSignOnClient().NewListPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.SingleSignOnResourceListResult = armdynatrace.SingleSignOnResourceListResult{
	// 	Value: []*armdynatrace.SingleSignOnResource{
	// 		{
	// 			Name: to.Ptr("default"),
	// 			Type: to.Ptr("Dynatrace.Observability/monitors"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/singleSignOnConfigurations/default"),
	// 			Properties: &armdynatrace.SingleSignOnProperties{
	// 				AADDomains: []*string{
	// 					to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
	// 					EnterpriseAppID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 					ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
	// 					SingleSignOnState: to.Ptr(armdynatrace.SingleSignOnStatesEnable),
	// 					SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
	// 				},
	// 				SystemData: &armdynatrace.SystemData{
	// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
	// 					CreatedBy: to.Ptr("alice@microsoft.com"),
	// 					CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
	// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
	// 					LastModifiedBy: to.Ptr("alice@microsoft.com"),
	// 					LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
	// 				},
	// 		}},
	// 	}
}

Output:
Example (SingleSignOnListMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/SingleSignOn_List_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSingleSignOnClient().NewListPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.SingleSignOnResourceListResult = armdynatrace.SingleSignOnResourceListResult{
	// 	Value: []*armdynatrace.SingleSignOnResource{
	// 		{
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/singleSignOnConfigurations/default"),
	// 			Properties: &armdynatrace.SingleSignOnProperties{
	// 				AADDomains: []*string{
	// 					to.Ptr("mpliftrdt20210811outlook.onmicrosoft.com")},
	// 					SingleSignOnURL: to.Ptr("https://www.dynatrace.io/IAmSomeHash"),
	// 				},
	// 		}},
	// 	}
}

Output:

type SingleSignOnClientBeginCreateOrUpdateOptions 

type SingleSignOnClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

SingleSignOnClientBeginCreateOrUpdateOptions contains the optional parameters for the SingleSignOnClient.BeginCreateOrUpdate method.

type SingleSignOnClientCreateOrUpdateResponse 

type SingleSignOnClientCreateOrUpdateResponse struct {
	// Single sign-on configurations for a given monitor resource.
	SingleSignOnResource
}

SingleSignOnClientCreateOrUpdateResponse contains the response from method SingleSignOnClient.BeginCreateOrUpdate.

type SingleSignOnClientGetOptions 

type SingleSignOnClientGetOptions struct {
}

SingleSignOnClientGetOptions contains the optional parameters for the SingleSignOnClient.Get method.

type SingleSignOnClientGetResponse 

type SingleSignOnClientGetResponse struct {
	// Single sign-on configurations for a given monitor resource.
	SingleSignOnResource
}

SingleSignOnClientGetResponse contains the response from method SingleSignOnClient.Get.

type SingleSignOnClientListOptions 

type SingleSignOnClientListOptions struct {
}

SingleSignOnClientListOptions contains the optional parameters for the SingleSignOnClient.NewListPager method.

type SingleSignOnClientListResponse 

type SingleSignOnClientListResponse struct {
	// The response of a DynatraceSingleSignOnResource list operation.
	SingleSignOnResourceListResult
}

SingleSignOnClientListResponse contains the response from method SingleSignOnClient.NewListPager.

type SingleSignOnProperties 

type SingleSignOnProperties struct {
	// array of Aad(azure active directory) domains
	AADDomains []*string

	// Version of the Dynatrace agent installed on the VM.
	EnterpriseAppID *string

	// State of Single Sign On
	SingleSignOnState *SingleSignOnStates

	// The login URL specific to this Dynatrace Environment
	SingleSignOnURL *string

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

SingleSignOnProperties - The details of a Dynatrace single sign-on.

func (SingleSignOnProperties) MarshalJSON 

func (s SingleSignOnProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SingleSignOnProperties.

func (*SingleSignOnProperties) UnmarshalJSON 

func (s *SingleSignOnProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SingleSignOnProperties.

type SingleSignOnResource 

type SingleSignOnResource struct {
	// REQUIRED; The resource-specific properties for this resource.
	Properties *SingleSignOnProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; System metadata for this resource.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

SingleSignOnResource - Single sign-on configurations for a given monitor resource.

func (SingleSignOnResource) MarshalJSON 

func (s SingleSignOnResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SingleSignOnResource.

func (*SingleSignOnResource) UnmarshalJSON 

func (s *SingleSignOnResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SingleSignOnResource.

type SingleSignOnResourceListResult 

type SingleSignOnResourceListResult struct {
	// REQUIRED; The items on this page
	Value []*SingleSignOnResource

	// The link to the next page of items
	NextLink *string
}

SingleSignOnResourceListResult - The response of a DynatraceSingleSignOnResource list operation.

func (SingleSignOnResourceListResult) MarshalJSON 

func (s SingleSignOnResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SingleSignOnResourceListResult.

func (*SingleSignOnResourceListResult) UnmarshalJSON 

func (s *SingleSignOnResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SingleSignOnResourceListResult.

type SingleSignOnStates 

type SingleSignOnStates string

SingleSignOnStates - Various states of the SSO resource 

const (
	SingleSignOnStatesDisable  SingleSignOnStates = "Disable"
	SingleSignOnStatesEnable   SingleSignOnStates = "Enable"
	SingleSignOnStatesExisting SingleSignOnStates = "Existing"
	SingleSignOnStatesInitial  SingleSignOnStates = "Initial"
)

func PossibleSingleSignOnStatesValues 

func PossibleSingleSignOnStatesValues() []SingleSignOnStates

PossibleSingleSignOnStatesValues returns the possible values for the SingleSignOnStates const type.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TagAction 

type TagAction string

TagAction - Valid actions for a filtering tag. Exclusion takes priority over inclusion. 

const (
	TagActionExclude TagAction = "Exclude"
	TagActionInclude TagAction = "Include"
)

func PossibleTagActionValues 

func PossibleTagActionValues() []TagAction

PossibleTagActionValues returns the possible values for the TagAction const type.

type TagRule 

type TagRule struct {
	// REQUIRED; The resource-specific properties for this resource.
	Properties *MonitoringTagRulesProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; System metadata for this resource.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

TagRule - Tag rules for a monitor resource

func (TagRule) MarshalJSON 

func (t TagRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TagRule.

func (*TagRule) UnmarshalJSON 

func (t *TagRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TagRule.

type TagRuleListResult 

type TagRuleListResult struct {
	// REQUIRED; The items on this page
	Value []*TagRule

	// The link to the next page of items
	NextLink *string
}

TagRuleListResult - The response of a TagRule list operation.

func (TagRuleListResult) MarshalJSON 

func (t TagRuleListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TagRuleListResult.

func (*TagRuleListResult) UnmarshalJSON 

func (t *TagRuleListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TagRuleListResult.

type TagRulesClient 

type TagRulesClient struct {
	// contains filtered or unexported fields
}

TagRulesClient contains the methods for the TagRules group. Don't use this type directly, use NewTagRulesClient() instead.

func NewTagRulesClient 

func NewTagRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*TagRulesClient, error)

NewTagRulesClient creates a new instance of TagRulesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*TagRulesClient) BeginCreateOrUpdate 

func (client *TagRulesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, monitorName string, ruleSetName string, resource TagRule, options *TagRulesClientBeginCreateOrUpdateOptions) (*runtime.Poller[TagRulesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a TagRule If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • ruleSetName - Monitor resource name
  • resource - Resource create parameters.
  • options - TagRulesClientBeginCreateOrUpdateOptions contains the optional parameters for the TagRulesClient.BeginCreateOrUpdate method.
Example (TagRulesCreateOrUpdateMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/TagRules_CreateOrUpdate_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewTagRulesClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myMonitor", "default", armdynatrace.TagRule{
	Properties: &armdynatrace.MonitoringTagRulesProperties{
		LogRules: &armdynatrace.LogRules{
			FilteringTags: []*armdynatrace.FilteringTag{
				{
					Name:   to.Ptr("Environment"),
					Action: to.Ptr(armdynatrace.TagActionInclude),
					Value:  to.Ptr("Prod"),
				},
				{
					Name:   to.Ptr("Environment"),
					Action: to.Ptr(armdynatrace.TagActionExclude),
					Value:  to.Ptr("Dev"),
				}},
			SendAADLogs:          to.Ptr(armdynatrace.SendAADLogsStatusEnabled),
			SendActivityLogs:     to.Ptr(armdynatrace.SendActivityLogsStatusEnabled),
			SendSubscriptionLogs: to.Ptr(armdynatrace.SendSubscriptionLogsStatusEnabled),
		},
		MetricRules: &armdynatrace.MetricRules{
			FilteringTags: []*armdynatrace.FilteringTag{
				{
					Name:   to.Ptr("Environment"),
					Action: to.Ptr(armdynatrace.TagActionInclude),
					Value:  to.Ptr("Prod"),
				}},
			SendingMetrics: to.Ptr(armdynatrace.SendingMetricsStatusEnabled),
		},
		ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateAccepted),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.TagRule = armdynatrace.TagRule{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Dynatrace.Observability/monitors/tagRules"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/tagRules/default"),
// 	Properties: &armdynatrace.MonitoringTagRulesProperties{
// 		LogRules: &armdynatrace.LogRules{
// 			FilteringTags: []*armdynatrace.FilteringTag{
// 				{
// 					Name: to.Ptr("Environment"),
// 					Action: to.Ptr(armdynatrace.TagActionInclude),
// 					Value: to.Ptr("Prod"),
// 				},
// 				{
// 					Name: to.Ptr("Environment"),
// 					Action: to.Ptr(armdynatrace.TagActionExclude),
// 					Value: to.Ptr("Dev"),
// 			}},
// 			SendAADLogs: to.Ptr(armdynatrace.SendAADLogsStatusEnabled),
// 			SendActivityLogs: to.Ptr(armdynatrace.SendActivityLogsStatusEnabled),
// 			SendSubscriptionLogs: to.Ptr(armdynatrace.SendSubscriptionLogsStatusEnabled),
// 		},
// 		MetricRules: &armdynatrace.MetricRules{
// 			FilteringTags: []*armdynatrace.FilteringTag{
// 				{
// 					Name: to.Ptr("Environment"),
// 					Action: to.Ptr(armdynatrace.TagActionInclude),
// 					Value: to.Ptr("Prod"),
// 			}},
// 			SendingMetrics: to.Ptr(armdynatrace.SendingMetricsStatusEnabled),
// 		},
// 		ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
// 	},
// 	SystemData: &armdynatrace.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 		CreatedBy: to.Ptr("alice@microsoft.com"),
// 		CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 		LastModifiedBy: to.Ptr("alice@microsoft.com"),
// 		LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 	},
// }

Output:
Example (TagRulesCreateOrUpdateMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/TagRules_CreateOrUpdate_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewTagRulesClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myMonitor", "default", armdynatrace.TagRule{
	Properties: &armdynatrace.MonitoringTagRulesProperties{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.TagRule = armdynatrace.TagRule{
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/tagRules/default"),
// 	Properties: &armdynatrace.MonitoringTagRulesProperties{
// 	},
// }

Output:

func (*TagRulesClient) BeginDelete 

func (client *TagRulesClient) BeginDelete(ctx context.Context, resourceGroupName string, monitorName string, ruleSetName string, options *TagRulesClientBeginDeleteOptions) (*runtime.Poller[TagRulesClientDeleteResponse], error)

BeginDelete - Delete a TagRule If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • ruleSetName - Monitor resource name
  • options - TagRulesClientBeginDeleteOptions contains the optional parameters for the TagRulesClient.BeginDelete method.
Example (TagRulesDeleteMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/TagRules_Delete_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewTagRulesClient().BeginDelete(ctx, "myResourceGroup", "myMonitor", "default", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:
Example (TagRulesDeleteMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/TagRules_Delete_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewTagRulesClient().BeginDelete(ctx, "myResourceGroup", "myMonitor", "default", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*TagRulesClient) Get 

func (client *TagRulesClient) Get(ctx context.Context, resourceGroupName string, monitorName string, ruleSetName string, options *TagRulesClientGetOptions) (TagRulesClientGetResponse, error)

Get - Get a TagRule If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • ruleSetName - Monitor resource name
  • options - TagRulesClientGetOptions contains the optional parameters for the TagRulesClient.Get method.
Example (TagRulesGetMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/TagRules_Get_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewTagRulesClient().Get(ctx, "myResourceGroup", "myMonitor", "default", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.TagRule = armdynatrace.TagRule{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Dynatrace.Observability/monitors/tagRules"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/tagRules/default"),
// 	Properties: &armdynatrace.MonitoringTagRulesProperties{
// 		LogRules: &armdynatrace.LogRules{
// 			FilteringTags: []*armdynatrace.FilteringTag{
// 				{
// 					Name: to.Ptr("Environment"),
// 					Action: to.Ptr(armdynatrace.TagActionInclude),
// 					Value: to.Ptr("Prod"),
// 				},
// 				{
// 					Name: to.Ptr("Environment"),
// 					Action: to.Ptr(armdynatrace.TagActionExclude),
// 					Value: to.Ptr("Dev"),
// 			}},
// 			SendAADLogs: to.Ptr(armdynatrace.SendAADLogsStatusEnabled),
// 			SendActivityLogs: to.Ptr(armdynatrace.SendActivityLogsStatusEnabled),
// 			SendSubscriptionLogs: to.Ptr(armdynatrace.SendSubscriptionLogsStatusEnabled),
// 		},
// 		MetricRules: &armdynatrace.MetricRules{
// 			FilteringTags: []*armdynatrace.FilteringTag{
// 				{
// 					Name: to.Ptr("Environment"),
// 					Action: to.Ptr(armdynatrace.TagActionInclude),
// 					Value: to.Ptr("Prod"),
// 			}},
// 			SendingMetrics: to.Ptr(armdynatrace.SendingMetricsStatusEnabled),
// 		},
// 		ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
// 	},
// 	SystemData: &armdynatrace.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 		CreatedBy: to.Ptr("alice@microsoft.com"),
// 		CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
// 		LastModifiedBy: to.Ptr("alice@microsoft.com"),
// 		LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
// 	},
// }

Output:
Example (TagRulesGetMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/TagRules_Get_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewTagRulesClient().Get(ctx, "myResourceGroup", "myMonitor", "default", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.TagRule = armdynatrace.TagRule{
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/tagRules/default"),
// 	Properties: &armdynatrace.MonitoringTagRulesProperties{
// 	},
// }

Output:

func (*TagRulesClient) NewListPager 

func (client *TagRulesClient) NewListPager(resourceGroupName string, monitorName string, options *TagRulesClientListOptions) *runtime.Pager[TagRulesClientListResponse]

NewListPager - List all TagRule by monitorName

Generated from API version 2023-04-27

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • monitorName - Monitor resource name
  • options - TagRulesClientListOptions contains the optional parameters for the TagRulesClient.NewListPager method.
Example (TagRulesListMaximumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/TagRules_List_MaximumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewTagRulesClient().NewListPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.TagRuleListResult = armdynatrace.TagRuleListResult{
	// 	Value: []*armdynatrace.TagRule{
	// 		{
	// 			Name: to.Ptr("default"),
	// 			Type: to.Ptr("Dynatrace.Observability/monitors/tagRules"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/tagRules/default"),
	// 			Properties: &armdynatrace.MonitoringTagRulesProperties{
	// 				LogRules: &armdynatrace.LogRules{
	// 					FilteringTags: []*armdynatrace.FilteringTag{
	// 						{
	// 							Name: to.Ptr("Environment"),
	// 							Action: to.Ptr(armdynatrace.TagActionInclude),
	// 							Value: to.Ptr("Prod"),
	// 						},
	// 						{
	// 							Name: to.Ptr("Environment"),
	// 							Action: to.Ptr(armdynatrace.TagActionExclude),
	// 							Value: to.Ptr("Dev"),
	// 					}},
	// 					SendAADLogs: to.Ptr(armdynatrace.SendAADLogsStatusEnabled),
	// 					SendActivityLogs: to.Ptr(armdynatrace.SendActivityLogsStatusEnabled),
	// 					SendSubscriptionLogs: to.Ptr(armdynatrace.SendSubscriptionLogsStatusEnabled),
	// 				},
	// 				MetricRules: &armdynatrace.MetricRules{
	// 					FilteringTags: []*armdynatrace.FilteringTag{
	// 						{
	// 							Name: to.Ptr("Environment"),
	// 							Action: to.Ptr(armdynatrace.TagActionInclude),
	// 							Value: to.Ptr("Prod"),
	// 					}},
	// 					SendingMetrics: to.Ptr(armdynatrace.SendingMetricsStatusEnabled),
	// 				},
	// 				ProvisioningState: to.Ptr(armdynatrace.ProvisioningStateSucceeded),
	// 			},
	// 			SystemData: &armdynatrace.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
	// 				CreatedBy: to.Ptr("alice@microsoft.com"),
	// 				CreatedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-16T04:25:21.040Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("alice@microsoft.com"),
	// 				LastModifiedByType: to.Ptr(armdynatrace.CreatedByTypeUser),
	// 			},
	// 	}},
	// }
}

Output:
Example (TagRulesListMinimumSetGen)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/baac183ffa684d94f697f0fc6f480e02cfb00f3d/specification/dynatrace/resource-manager/Dynatrace.Observability/stable/2023-04-27/examples/TagRules_List_MinimumSet_Gen.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armdynatrace.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewTagRulesClient().NewListPager("myResourceGroup", "myMonitor", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.TagRuleListResult = armdynatrace.TagRuleListResult{
	// 	Value: []*armdynatrace.TagRule{
	// 		{
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Dynatrace.Observability/monitors/myMonitor/tagRules/default"),
	// 			Properties: &armdynatrace.MonitoringTagRulesProperties{
	// 			},
	// 	}},
	// }
}

Output:

type TagRulesClientBeginCreateOrUpdateOptions 

type TagRulesClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

TagRulesClientBeginCreateOrUpdateOptions contains the optional parameters for the TagRulesClient.BeginCreateOrUpdate method.

type TagRulesClientBeginDeleteOptions 

type TagRulesClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

TagRulesClientBeginDeleteOptions contains the optional parameters for the TagRulesClient.BeginDelete method.

type TagRulesClientCreateOrUpdateResponse 

type TagRulesClientCreateOrUpdateResponse struct {
	// Tag rules for a monitor resource
	TagRule
}

TagRulesClientCreateOrUpdateResponse contains the response from method TagRulesClient.BeginCreateOrUpdate.

type TagRulesClientDeleteResponse 

type TagRulesClientDeleteResponse struct {
}

TagRulesClientDeleteResponse contains the response from method TagRulesClient.BeginDelete.

type TagRulesClientGetOptions 

type TagRulesClientGetOptions struct {
}

TagRulesClientGetOptions contains the optional parameters for the TagRulesClient.Get method.

type TagRulesClientGetResponse 

type TagRulesClientGetResponse struct {
	// Tag rules for a monitor resource
	TagRule
}

TagRulesClientGetResponse contains the response from method TagRulesClient.Get.

type TagRulesClientListOptions 

type TagRulesClientListOptions struct {
}

TagRulesClientListOptions contains the optional parameters for the TagRulesClient.NewListPager method.

type TagRulesClientListResponse 

type TagRulesClientListResponse struct {
	// The response of a TagRule list operation.
	TagRuleListResult
}

TagRulesClientListResponse contains the response from method TagRulesClient.NewListPager.

type UpdateStatus 

type UpdateStatus string

UpdateStatus - The current update status of OneAgent. 

const (
	UpdateStatusINCOMPATIBLE     UpdateStatus = "INCOMPATIBLE"
	UpdateStatusOUTDATED         UpdateStatus = "OUTDATED"
	UpdateStatusSCHEDULED        UpdateStatus = "SCHEDULED"
	UpdateStatusSUPPRESSED       UpdateStatus = "SUPPRESSED"
	UpdateStatusUNKNOWN          UpdateStatus = "UNKNOWN"
	UpdateStatusUP2DATE          UpdateStatus = "UP2DATE"
	UpdateStatusUPDATEINPROGRESS UpdateStatus = "UPDATE_IN_PROGRESS"
	UpdateStatusUPDATEPENDING    UpdateStatus = "UPDATE_PENDING"
	UpdateStatusUPDATEPROBLEM    UpdateStatus = "UPDATE_PROBLEM"
)

func PossibleUpdateStatusValues 

func PossibleUpdateStatusValues() []UpdateStatus

PossibleUpdateStatusValues returns the possible values for the UpdateStatus const type.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// REQUIRED; The active directory client identifier for this principal.
	ClientID *string

	// REQUIRED; The active directory identifier for this principal.
	PrincipalID *string
}

UserAssignedIdentity - A managed identity assigned by the user.

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type UserInfo 

type UserInfo struct {
	// Country of the user
	Country *string

	// Email of the user used by Dynatrace for contacting them if needed
	EmailAddress *string

	// First Name of the user
	FirstName *string

	// Last Name of the user
	LastName *string

	// Phone number of the user used by Dynatrace for contacting them if needed
	PhoneNumber *string
}

UserInfo - User info.

func (UserInfo) MarshalJSON 

func (u UserInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserInfo.

func (*UserInfo) UnmarshalJSON 

func (u *UserInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserInfo.

type VMExtensionPayload 

type VMExtensionPayload struct {
	// Id of the environment created
	EnvironmentID *string

	// Ingestion key of the environment
	IngestionKey *string
}

VMExtensionPayload - Response of payload to be passed while installing VM agent.

func (VMExtensionPayload) MarshalJSON 

func (v VMExtensionPayload) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMExtensionPayload.

func (*VMExtensionPayload) UnmarshalJSON 

func (v *VMExtensionPayload) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMExtensionPayload.

type VMHostsListResponse 

type VMHostsListResponse struct {
	// The link to the next page of items
	NextLink *string

	// The items on this page
	Value []*VMInfo
}

VMHostsListResponse - Response of a list VM Host Operation.

func (VMHostsListResponse) MarshalJSON 

func (v VMHostsListResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMHostsListResponse.

func (*VMHostsListResponse) UnmarshalJSON 

func (v *VMHostsListResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMHostsListResponse.

type VMInfo 

type VMInfo struct {
	// Update settings of OneAgent.
	AutoUpdateSetting *AutoUpdateSetting

	// The availability state of OneAgent.
	AvailabilityState *AvailabilityState

	// The name of the host group
	HostGroup *string

	// The name of the host
	HostName *string

	// Tells whether log modules are enabled or not
	LogModule *LogModule

	// The monitoring mode of OneAgent
	MonitoringType *MonitoringType

	// Azure VM resource ID
	ResourceID *string

	// The current update status of OneAgent.
	UpdateStatus *UpdateStatus

	// Version of the Dynatrace agent installed on the VM.
	Version *string
}

VMInfo - Details of VM Resource having Dynatrace OneAgent installed

func (VMInfo) MarshalJSON 

func (v VMInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMInfo.

func (*VMInfo) UnmarshalJSON 

func (v *VMInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMInfo.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.