johanste

from sys import Type
from typing import List

class Policy:
    ...


class RetryPolicy(Policy):

    def __init__(self, max_retries=4, timeout=None):

johanste

import asyncio
import threading


class Client:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.loop.call_soon_threadsafe(self.loop.stop)

johanste

import asyncio
import time

class GeneratedSyncClient:

    def mapper(self, result, mappings):
        if result['timeout'] in mappings:
            raise mappings[result['timeout']]()
        return result

johanste

class FakePagePaged:
    """ Iterable over pages of responses

    Only intended to show a straw-man for how it could be implemented
    """
    def __init__(self, item_paged):
        self._item_paged = item_paged

    def __iter__(self):
        return self

johanste

Two categories:

1. User has done nothing to enable distributed tracing (no tracing library or plugin referenced, no tracer configured/enabled
2. User is referencing a distributed tracing plugin and has configured/enabled tracing

For category 1, there are no observable effects. No tracing information is emitted in outgoing requests (e.g. no tracstate/tracecontext headers). Spans may be created in memory, but since no exporter is created/referenced, no span information is created. ISSUE: we could, in theory, still use the span information in logs.

For category 2, see below for what spans to create.

Example scenarios with spans created

johanste

Track 2 changes

CosmosClient:

• Constructor should take a credentials instance.
  • Credentials classes should be created for the different auth modes we support (master keys and resource tokens)
• Connection policy arguments should be flattened out to **kwargs.
• proxy configuration should support the settings/environment variables and take an azure-core ProxyPolicy-like object (https://github.com/Azure/azure-sdk-for-python/blob/f2b072688d3dc688fed3905c558cff1fa0849b91/sdk/core/azure-core/azure/core/pipeline/policies/universal.py#L388)

Most prominent per-service-request args to change:

johanste

import collections

partition_ids = range(1, 7)
ownerships = [
    {
        'last_modified_time': 7,
        'partition_id': 1,
        'ownership': 1
    },
    {

johanste

class JsonPatchProxy:

    def __init__(self, wrapped, *, root=None, selector=''):
        self.__wrapped = wrapped
        self.__root = root or self
        self.__selector = selector
        self.__operations = []

    def __getattr__(self, name):
        attr = getattr(self.__wrapped, name)

johanste

Azure REST API review board

• Approval by the board is part of the PLR criteria for services
• Looks at adherence to the Microsoft REST API Guidelines + Azure REST API Guidelines
• Follow good practices, avoid anti-patterns across Azure services.
  • Paging
  • Long running operations
  • Error schemas
  • Versioning

Who are on the review board

johanste

As a user, I want to create an update. The update take a manifest as input. I do not get a chance to give my update a name - the name is generated by the service. Creating the update can take a long time, and the process can fail in ways that cannot be validated on the initial request since the validation is too costly. If the create fails at any point in time, no update resource will be created.

It is tempting to, as an implementor of a service, use globally unique identifiers as keys. However, if there is any possibilty to use a natural key, that is preferred. Humans are bad a remembering GUIDs. A hybrid apprach is to allow the user to optionally specify a key, and generate a key if one is not provided. The hybrid apprach makes it possible to make the operation idempotent.

There is no need for me (as a user) to list all updates that are being created at any given time. Only the user who is creating a user (or someone they hand off the process to) need to monitor the progress.

This requireme