or run

tessl search
Log in

Version

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
golangpkg:golang/github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus@v1.10.0

docs

admin

index.mdqueues.mdrules.mdsubscriptions.mdtopics.md
client.mderrors.mdindex.mdmessaging.mdreceiver.mdsender.mdsessions.md
tile.json

tessl/golang-github-com--azure--azure-sdk-for-go--sdk--messaging--azservicebus

tessl install tessl/golang-github-com--azure--azure-sdk-for-go--sdk--messaging--azservicebus@1.10.1

Client module for Azure Service Bus, a highly reliable cloud messaging service providing real-time and fault-tolerant communication between distributed senders and receivers.

queues.mddocs/admin/

Queue Management

Queue management operations in the admin client enable creating, configuring, updating, and monitoring Service Bus queues.

Capabilities

Create Queue

func (ac *Client) CreateQueue(ctx context.Context, queueName string, options *CreateQueueOptions) (CreateQueueResponse, error)

Creates a queue with configurable properties.

Example:

resp, err := adminClient.CreateQueue(context.Background(), "myqueue", &admin.CreateQueueOptions{
    Properties: &admin.QueueProperties{
        LockDuration:                     to.Ptr("PT1M"),     // 1 minute
        MaxSizeInMegabytes:               to.Ptr(int32(2048)),
        RequiresDuplicateDetection:       to.Ptr(true),
        RequiresSession:                  to.Ptr(false),
        DefaultMessageTimeToLive:         to.Ptr("P14D"),     // 14 days
        DeadLetteringOnMessageExpiration: to.Ptr(true),
        DuplicateDetectionHistoryTimeWindow: to.Ptr("PT10M"), // 10 minutes
        MaxDeliveryCount:                 to.Ptr(int32(10)),
        EnableBatchedOperations:          to.Ptr(true),
        EnablePartitioning:               to.Ptr(true),
    },
})
if err != nil {
    panic(err)
}

fmt.Printf("Created queue: %s\n", resp.QueueName)

Get Queue

func (ac *Client) GetQueue(ctx context.Context, queueName string, options *GetQueueOptions) (*GetQueueResponse, error)

Gets queue configuration properties by name. Returns nil response and nil error if the queue does not exist.

Example:

resp, err := adminClient.GetQueue(context.Background(), "myqueue", nil)
if err != nil {
    panic(err)
}

if resp == nil {
    fmt.Println("Queue does not exist")
    return
}

fmt.Printf("Queue: %s\n", resp.QueueName)
if resp.MaxDeliveryCount != nil {
    fmt.Printf("Max Delivery Count: %d\n", *resp.MaxDeliveryCount)
}
if resp.LockDuration != nil {
    fmt.Printf("Lock Duration: %s\n", *resp.LockDuration)
}

Get Queue Runtime Properties

func (ac *Client) GetQueueRuntimeProperties(ctx context.Context, queueName string, options *GetQueueRuntimePropertiesOptions) (*GetQueueRuntimePropertiesResponse, error)

Gets runtime statistics for a queue including message counts and size. Returns nil response and nil error if the queue does not exist.

Example:

resp, err := adminClient.GetQueueRuntimeProperties(context.Background(), "myqueue", nil)
if err != nil {
    panic(err)
}

if resp != nil {
    fmt.Printf("Queue: %s\n", resp.QueueName)
    fmt.Printf("Active Messages: %d\n", resp.ActiveMessageCount)
    fmt.Printf("Dead Letter Messages: %d\n", resp.DeadLetterMessageCount)
    fmt.Printf("Scheduled Messages: %d\n", resp.ScheduledMessageCount)
    fmt.Printf("Total Messages: %d\n", resp.TotalMessageCount)
    fmt.Printf("Size: %d bytes\n", resp.SizeInBytes)
    fmt.Printf("Created At: %s\n", resp.CreatedAt)
    fmt.Printf("Updated At: %s\n", resp.UpdatedAt)
}

Update Queue

func (ac *Client) UpdateQueue(ctx context.Context, queueName string, properties QueueProperties, options *UpdateQueueOptions) (UpdateQueueResponse, error)

Updates an existing queue's configuration properties.

Example:

// Get current properties
queueResp, err := adminClient.GetQueue(context.Background(), "myqueue", nil)
if err != nil {
    panic(err)
}

// Modify specific properties
props := queueResp.QueueProperties
props.MaxDeliveryCount = to.Ptr(int32(5))
props.DefaultMessageTimeToLive = to.Ptr("P7D")  // 7 days

// Update queue
updateResp, err := adminClient.UpdateQueue(context.Background(), "myqueue", props, nil)
if err != nil {
    panic(err)
}

fmt.Printf("Updated queue: %s\n", updateResp.QueueName)

Delete Queue

func (ac *Client) DeleteQueue(ctx context.Context, queueName string, options *DeleteQueueOptions) (DeleteQueueResponse, error)

Deletes a queue.

Example:

_, err := adminClient.DeleteQueue(context.Background(), "myqueue", nil)
if err != nil {
    panic(err)
}

fmt.Println("Queue deleted successfully")

List Queues

func (ac *Client) NewListQueuesPager(options *ListQueuesOptions) *runtime.Pager[ListQueuesResponse]

Creates a pager for listing all queues with their configuration properties.

Example:

pager := adminClient.NewListQueuesPager(&admin.ListQueuesOptions{
    MaxPageSize: 20,
})

for pager.More() {
    page, err := pager.NextPage(context.Background())
    if err != nil {
        panic(err)
    }

    for _, queue := range page.Queues {
        fmt.Printf("Queue: %s\n", queue.QueueName)
        if queue.RequiresSession != nil && *queue.RequiresSession {
            fmt.Println("  - Session-enabled")
        }
        if queue.EnablePartitioning != nil && *queue.EnablePartitioning {
            fmt.Println("  - Partitioned")
        }
    }
}

List Queue Runtime Properties

func (ac *Client) NewListQueuesRuntimePropertiesPager(options *ListQueuesRuntimePropertiesOptions) *runtime.Pager[ListQueuesRuntimePropertiesResponse]

Creates a pager for listing runtime properties of all queues.

Example:

pager := adminClient.NewListQueuesRuntimePropertiesPager(&admin.ListQueuesRuntimePropertiesOptions{
    MaxPageSize: 20,
})

for pager.More() {
    page, err := pager.NextPage(context.Background())
    if err != nil {
        panic(err)
    }

    for _, queueProps := range page.QueueRuntimeProperties {
        fmt.Printf("%s: %d active, %d dead-letter, %d scheduled\n",
            queueProps.QueueName,
            queueProps.ActiveMessageCount,
            queueProps.DeadLetterMessageCount,
            queueProps.ScheduledMessageCount,
        )
    }
}

Types

QueueProperties

type QueueProperties struct {
    LockDuration *string
    MaxSizeInMegabytes *int32
    RequiresDuplicateDetection *bool
    RequiresSession *bool
    DefaultMessageTimeToLive *string
    DeadLetteringOnMessageExpiration *bool
    DuplicateDetectionHistoryTimeWindow *string
    MaxDeliveryCount *int32
    EnableBatchedOperations *bool
    Status *EntityStatus
    AutoDeleteOnIdle *string
    EnablePartitioning *bool
    ForwardTo *string
    ForwardDeadLetteredMessagesTo *string
    UserMetadata *string
    AuthorizationRules []AuthorizationRule
    MaxMessageSizeInKilobytes *int64
}

Configuration properties for a queue:

  • LockDuration: Duration a message is locked in PeekLock mode (ISO 8601 format, e.g., "PT1M" for 1 minute). Default: 1 minute.
  • MaxSizeInMegabytes: Maximum queue size in MB. Default: 1024 MB.
  • RequiresDuplicateDetection: Enable duplicate message detection based on MessageID.
  • RequiresSession: Enable session support for FIFO message ordering. Default: false.
  • DefaultMessageTimeToLive: Default message expiration time (ISO 8601 duration, e.g., "P14D" for 14 days).
  • DeadLetteringOnMessageExpiration: Move expired messages to dead letter queue.
  • DuplicateDetectionHistoryTimeWindow: Duplicate detection history window (ISO 8601 duration). Default: 10 minutes.
  • MaxDeliveryCount: Maximum delivery attempts before dead-lettering. Default: 10.
  • EnableBatchedOperations: Enable server-side batching for improved throughput.
  • Status: Queue status (Active, Disabled, SendDisabled, ReceiveDisabled).
  • AutoDeleteOnIdle: Auto-delete queue after idle period (ISO 8601 duration).
  • EnablePartitioning: Partition queue across multiple message brokers for higher throughput.
  • ForwardTo: Queue or topic name to forward messages to.
  • ForwardDeadLetteredMessagesTo: Queue or topic name to forward dead-lettered messages to.
  • UserMetadata: Custom metadata string.
  • AuthorizationRules: Security rules with keys and access rights.
  • MaxMessageSizeInKilobytes: Maximum message size in KB (Premium tier only).

QueueRuntimeProperties

type QueueRuntimeProperties struct {
    SizeInBytes int64
    CreatedAt time.Time
    UpdatedAt time.Time
    AccessedAt time.Time
    TotalMessageCount int64
    ActiveMessageCount int32
    DeadLetterMessageCount int32
    ScheduledMessageCount int32
    TransferDeadLetterMessageCount int32
    TransferMessageCount int32
}

Runtime statistics for a queue:

  • SizeInBytes: Current queue size in bytes
  • CreatedAt: Queue creation timestamp
  • UpdatedAt: Last update timestamp
  • AccessedAt: Last access timestamp
  • TotalMessageCount: Total number of messages in the queue
  • ActiveMessageCount: Number of active messages
  • DeadLetterMessageCount: Number of dead-lettered messages
  • ScheduledMessageCount: Number of scheduled messages
  • TransferDeadLetterMessageCount: Messages dead-lettered during forwarding
  • TransferMessageCount: Messages pending forwarding

CreateQueueOptions

type CreateQueueOptions struct {
    Properties *QueueProperties
}

Options for creating a queue:

  • Properties: Queue configuration properties

CreateQueueResponse

type CreateQueueResponse struct {
    QueueName string
    QueueProperties
}

Response from creating a queue, includes the queue name and all properties.

GetQueueOptions

type GetQueueOptions struct {
    // Currently empty, reserved for future expansion
}

Options for getting a queue.

GetQueueResponse

type GetQueueResponse struct {
    QueueName string
    QueueProperties
}

Response from getting a queue, includes the queue name and all properties.

GetQueueRuntimePropertiesOptions

type GetQueueRuntimePropertiesOptions struct {
    // Currently empty, reserved for future expansion
}

Options for getting queue runtime properties.

GetQueueRuntimePropertiesResponse

type GetQueueRuntimePropertiesResponse struct {
    QueueName string
    QueueRuntimeProperties
}

Response from getting queue runtime properties, includes the queue name and all runtime statistics.

UpdateQueueOptions

type UpdateQueueOptions struct {
    // Currently empty, reserved for future expansion
}

Options for updating a queue.

UpdateQueueResponse

type UpdateQueueResponse struct {
    QueueName string
    QueueProperties
}

Response from updating a queue, includes the queue name and updated properties.

DeleteQueueOptions

type DeleteQueueOptions struct {
    // Currently empty, reserved for future expansion
}

Options for deleting a queue.

DeleteQueueResponse

type DeleteQueueResponse struct {
    // Empty response
}

Response from deleting a queue.

ListQueuesOptions

type ListQueuesOptions struct {
    MaxPageSize int32
}

Options for listing queues:

  • MaxPageSize: Maximum number of queues per page

ListQueuesResponse

type ListQueuesResponse struct {
    Queues []QueueItem
}

Response from listing queues.

QueueItem

type QueueItem struct {
    QueueName string
    QueueProperties
}

A single queue item in the list response.

ListQueuesRuntimePropertiesOptions

type ListQueuesRuntimePropertiesOptions struct {
    MaxPageSize int32
}

Options for listing queue runtime properties:

  • MaxPageSize: Maximum number of queues per page

ListQueuesRuntimePropertiesResponse

type ListQueuesRuntimePropertiesResponse struct {
    QueueRuntimeProperties []QueueRuntimePropertiesItem
}

Response from listing queue runtime properties.

QueueRuntimePropertiesItem

type QueueRuntimePropertiesItem struct {
    QueueName string
    QueueRuntimeProperties
}

A single queue runtime properties item in the list response.

Usage Patterns

Create Session-Enabled Queue

resp, err := adminClient.CreateQueue(context.Background(), "orders-queue", &admin.CreateQueueOptions{
    Properties: &admin.QueueProperties{
        RequiresSession:          to.Ptr(true),
        LockDuration:             to.Ptr("PT5M"),
        MaxDeliveryCount:         to.Ptr(int32(3)),
        DefaultMessageTimeToLive: to.Ptr("P1D"),
    },
})

Create Queue with Forwarding

// Create dead letter destination
adminClient.CreateQueue(context.Background(), "failed-messages", nil)

// Create main queue with dead letter forwarding
resp, err := adminClient.CreateQueue(context.Background(), "processing-queue", &admin.CreateQueueOptions{
    Properties: &admin.QueueProperties{
        MaxDeliveryCount:              to.Ptr(int32(5)),
        ForwardDeadLetteredMessagesTo: to.Ptr("failed-messages"),
    },
})

Create Partitioned Queue (High Throughput)

resp, err := adminClient.CreateQueue(context.Background(), "high-throughput-queue", &admin.CreateQueueOptions{
    Properties: &admin.QueueProperties{
        EnablePartitioning: to.Ptr(true),
        MaxSizeInMegabytes: to.Ptr(int32(5120)),  // Larger size for partitioned queues
    },
})

Create Queue with Duplicate Detection

resp, err := adminClient.CreateQueue(context.Background(), "idempotent-queue", &admin.CreateQueueOptions{
    Properties: &admin.QueueProperties{
        RequiresDuplicateDetection:          to.Ptr(true),
        DuplicateDetectionHistoryTimeWindow: to.Ptr("PT1H"),  // 1 hour window
    },
})

Monitor Queue Health

func monitorQueueHealth(adminClient *admin.Client, queueName string) {
    ticker := time.NewTicker(time.Minute)
    defer ticker.Stop()

    for range ticker.C {
        resp, err := adminClient.GetQueueRuntimeProperties(context.Background(), queueName, nil)
        if err != nil {
            log.Printf("Error getting queue properties: %v", err)
            continue
        }

        // Alert on dead letter messages
        if resp.DeadLetterMessageCount > 10 {
            log.Printf("WARNING: %d messages in dead letter queue", resp.DeadLetterMessageCount)
        }

        // Alert on queue size
        if resp.SizeInBytes > 1024*1024*1024 {  // 1 GB
            log.Printf("WARNING: Queue size is %d bytes", resp.SizeInBytes)
        }

        // Monitor message backlog
        if resp.ActiveMessageCount > 1000 {
            log.Printf("High message count: %d active messages", resp.ActiveMessageCount)
        }
    }
}

Update Queue Dynamically

func scaleQueueDeliveryAttempts(adminClient *admin.Client, queueName string, maxDelivery int32) error {
    // Get current properties
    resp, err := adminClient.GetQueue(context.Background(), queueName, nil)
    if err != nil {
        return err
    }

    if resp == nil {
        return fmt.Errorf("queue not found")
    }

    // Update max delivery count
    props := resp.QueueProperties
    props.MaxDeliveryCount = to.Ptr(maxDelivery)

    _, err = adminClient.UpdateQueue(context.Background(), queueName, props, nil)
    return err
}