From 4ad539be26744cae9d8af3bbe6c5c668d9e4f058 Mon Sep 17 00:00:00 2001 From: Vlad Barosan Date: Mon, 22 Oct 2018 15:11:58 -0700 Subject: [PATCH] Emit spans for sdk (#156) * Emit spans for SDK calls * Add context to pages and iterators * Add tracing to pages and iterators * Regenerate tests * Add null checks * Avoid name conflicts from embedded structs * Address feedback * Remove comment for use of IsEnabled * don't use fmt --- src/CodeNamerGo.cs | 8 +- src/Model/CodeModelGo.cs | 26 +- src/Model/IteratorTypeGo.cs | 6 + src/Model/MethodGo.cs | 6 +- src/Model/MethodGroupGo.cs | 4 +- src/Model/PageTypeGo.cs | 7 +- src/Templates/MethodTemplate.cshtml | 400 +++++----- src/Templates/ModelTemplate.cshtml | 653 +++++++++-------- src/Templates/ModelsTemplate.cshtml | 4 + test/src/tests/Gopkg.lock | 173 ++++- test/src/tests/Gopkg.toml | 2 +- .../generated/additional-properties/models.go | 3 + .../generated/additional-properties/pets.go | 61 ++ .../src/tests/generated/azurereport/client.go | 11 + .../src/tests/generated/azurereport/models.go | 3 + test/src/tests/generated/body-array/array.go | 691 ++++++++++++++++++ test/src/tests/generated/body-array/models.go | 3 + test/src/tests/generated/body-boolean/bool.go | 61 ++ .../tests/generated/body-boolean/models.go | 3 + test/src/tests/generated/body-byte/byte.go | 51 ++ test/src/tests/generated/body-byte/models.go | 3 + .../src/tests/generated/body-complex/array.go | 51 ++ .../src/tests/generated/body-complex/basic.go | 61 ++ .../generated/body-complex/dictionary.go | 61 ++ .../generated/body-complex/flattencomplex.go | 11 + .../generated/body-complex/inheritance.go | 21 + .../tests/generated/body-complex/models.go | 3 + .../body-complex/polymorphicrecursive.go | 21 + .../generated/body-complex/polymorphism.go | 61 ++ .../tests/generated/body-complex/primitive.go | 221 ++++++ .../body-complex/readonlyproperty.go | 21 + test/src/tests/generated/body-date/date.go | 81 ++ test/src/tests/generated/body-date/models.go | 3 + .../body-datetime-rfc1123/datetimerfc1123.go | 91 +++ .../generated/body-datetime-rfc1123/models.go | 3 + .../tests/generated/body-datetime/datetime.go | 191 +++++ .../tests/generated/body-datetime/models.go | 3 + .../generated/body-dictionary/dictionary.go | 651 +++++++++++++++++ .../tests/generated/body-dictionary/models.go | 3 + .../tests/generated/body-duration/duration.go | 41 ++ .../tests/generated/body-duration/models.go | 3 + test/src/tests/generated/body-file/files.go | 31 + test/src/tests/generated/body-file/models.go | 3 + .../tests/generated/body-formdata/formdata.go | 21 + .../tests/generated/body-formdata/models.go | 3 + test/src/tests/generated/body-integer/int.go | 141 ++++ .../tests/generated/body-integer/models.go | 3 + .../src/tests/generated/body-number/models.go | 3 + .../src/tests/generated/body-number/number.go | 241 ++++++ test/src/tests/generated/body-string/enum.go | 61 ++ .../src/tests/generated/body-string/models.go | 3 + .../src/tests/generated/body-string/string.go | 131 ++++ .../tests/generated/custom-baseurl/models.go | 3 + .../tests/generated/custom-baseurl/paths.go | 11 + test/src/tests/generated/header/header.go | 291 ++++++++ test/src/tests/generated/header/models.go | 3 + .../httpinfrastructure/httpclientfailure.go | 231 ++++++ .../httpinfrastructure/httpfailure.go | 31 + .../httpinfrastructure/httpredirects.go | 151 ++++ .../generated/httpinfrastructure/httpretry.go | 81 ++ .../httpinfrastructure/httpserverfailure.go | 41 ++ .../httpinfrastructure/httpsuccess.go | 181 +++++ .../generated/httpinfrastructure/models.go | 3 + .../httpinfrastructure/multipleresponses.go | 341 +++++++++ test/src/tests/generated/lro/lroretrys.go | 71 ++ test/src/tests/generated/lro/lros.go | 391 ++++++++++ test/src/tests/generated/lro/lrosads.go | 261 +++++++ .../tests/generated/lro/lroscustomheader.go | 41 ++ test/src/tests/generated/lro/models.go | 230 +++--- .../generated/model-flattening/client.go | 111 +++ .../generated/model-flattening/models.go | 3 + .../generated/more-custom-base-uri/models.go | 3 + .../generated/more-custom-base-uri/paths.go | 11 + test/src/tests/generated/paging/models.go | 117 ++- test/src/tests/generated/paging/paging.go | 305 +++++++- test/src/tests/generated/report/client.go | 11 + test/src/tests/generated/report/models.go | 3 + .../generated/required-optional/explicit.go | 221 ++++++ .../generated/required-optional/implicit.go | 71 ++ .../generated/required-optional/models.go | 3 + test/src/tests/generated/url/models.go | 3 + test/src/tests/generated/url/pathitems.go | 41 ++ test/src/tests/generated/url/paths.go | 261 +++++++ test/src/tests/generated/url/queries.go | 341 +++++++++ test/src/tests/generated/validation/client.go | 41 ++ test/src/tests/generated/validation/models.go | 3 + 86 files changed, 7685 insertions(+), 648 deletions(-) diff --git a/src/CodeNamerGo.cs b/src/CodeNamerGo.cs index ad93505be..7a6d4c49e 100644 --- a/src/CodeNamerGo.cs +++ b/src/CodeNamerGo.cs @@ -20,20 +20,24 @@ public class CodeNamerGo : CodeNamer public virtual IEnumerable AutorestImports => new string[] { PrimaryTypeGo.GetImportLine(package: "github.com/Azure/go-autorest/autorest") }; + public virtual IEnumerable TracingImports => new string[] { PrimaryTypeGo.GetImportLine(package: "github.com/Azure/go-autorest/tracing") }; + public virtual IEnumerable StandardImports => new string[] { PrimaryTypeGo.GetImportLine(package: "github.com/Azure/go-autorest/autorest/azure"), PrimaryTypeGo.GetImportLine(package: "net/http"), - PrimaryTypeGo.GetImportLine(package: "context") + PrimaryTypeGo.GetImportLine(package: "context"), }; public virtual IEnumerable PageableImports => new string[] { PrimaryTypeGo.GetImportLine(package: "net/http"), + PrimaryTypeGo.GetImportLine(package: "context"), + PrimaryTypeGo.GetImportLine(package: "github.com/Azure/go-autorest/tracing"), PrimaryTypeGo.GetImportLine(package: "github.com/Azure/go-autorest/autorest/to") }; - public virtual IEnumerable ValidationImport => new string[] { PrimaryTypeGo.GetImportLine(package: "github.com/Azure/go-autorest/autorest/validation") }; + public virtual IEnumerable ValidationImports => new string[] { PrimaryTypeGo.GetImportLine(package: "github.com/Azure/go-autorest/autorest/validation") }; public string[] UserDefinedNames => new string[] { "UserAgent", diff --git a/src/Model/CodeModelGo.cs b/src/Model/CodeModelGo.cs index 8139bce6d..21d937a85 100644 --- a/src/Model/CodeModelGo.cs +++ b/src/Model/CodeModelGo.cs @@ -7,6 +7,7 @@ using AutoRest.Extensions; using System; using System.Collections.Generic; +using System.IO; using System.Linq; using System.Text; using System.Text.RegularExpressions; @@ -17,6 +18,7 @@ public class CodeModelGo : CodeModel { public static readonly string OneVerString = "version.Number"; private static readonly Regex semVerPattern = new Regex(@"^v?(?\d+)\.(?\d+)\.(?\d+)(?:-(?\S+))?$", RegexOptions.Compiled); + private const string sdkFqdnPrefix = "github.com/Azure/azure-sdk-for-go"; public CodeModelGo() { @@ -106,6 +108,28 @@ private string SpecifiedUserAgent public string APIType => Settings.Instance.Host?.GetValue("openapi-type").Result; + public string PackageFqdn + { + get + { + var outDir = Settings.Instance.Host?.GetValue("output-folder").Result.ToLowerInvariant().Replace("\\", "/"); + var sdkPath = Settings.Instance.Host?.GetValue("go-sdk-folder").Result?.ToLowerInvariant().Replace("\\", "/").Trim(); + + if (!string.IsNullOrEmpty(sdkPath)) + { + return $"{sdkFqdnPrefix}/{outDir.Split(sdkPath, StringSplitOptions.None).Last()}"; + } + else if (!Path.IsPathRooted(outDir)) + { + return outDir; + } + else + { + return outDir.Substring(Path.GetPathRoot(outDir).Length); + } + } + } + public IEnumerable ClientImports { get @@ -303,7 +327,7 @@ public override string Namespace /// FormatVersion normalizes a version string into a SemVer if it resembles one. Otherwise, /// it returns the original string unmodified. If version is empty or only comprised of - /// whitespace, + /// whitespace, public static string FormatVersion(string version) { diff --git a/src/Model/IteratorTypeGo.cs b/src/Model/IteratorTypeGo.cs index dccfa522b..e1bd36126 100644 --- a/src/Model/IteratorTypeGo.cs +++ b/src/Model/IteratorTypeGo.cs @@ -22,6 +22,7 @@ internal class IteratorTypeGo : CompositeTypeGo public IteratorTypeGo(PageTypeGo pageType) : base(CodeNamerGo.Instance.GetIteratorTypeName(pageType)) { PageType = pageType; + CodeModel = pageType.CodeModel; Documentation = $"Provides access to a complete listing of {PageType.ElementType.Name} values."; } @@ -35,6 +36,11 @@ public IteratorTypeGo(PageTypeGo pageType) : base(CodeNamerGo.Instance.GetIterat /// public string IndexField => "i"; + /// + /// The qualified name for the advancer method. + /// + public string AdvancerQualifiedName => $"{Name}.NextWithContext"; + /// /// Gets the name of the page field that contains the current page of values. /// diff --git a/src/Model/MethodGo.cs b/src/Model/MethodGo.cs index e4ec918f8..96d357e3d 100644 --- a/src/Model/MethodGo.cs +++ b/src/Model/MethodGo.cs @@ -30,6 +30,11 @@ public class MethodGo : Method public bool NextAlreadyDefined { get; private set; } + /// + /// The method name qualified with the client name + /// + public string QualifiedName => $"{Owner}.{Name}"; + public bool IsCustomBaseUri => CodeModel.Extensions.ContainsKey(SwaggerExtensions.ParameterizedHostExtension); @@ -47,7 +52,6 @@ internal void Transform(CodeModelGo cmg) Owner = (MethodGroup as MethodGroupGo).ClientName; PackageName = cmg.Namespace; NextAlreadyDefined = NextMethodExists(cmg.Methods.Cast()); - var apiVersionParam = from p in Parameters let name = p.SerializedName diff --git a/src/Model/MethodGroupGo.cs b/src/Model/MethodGroupGo.cs index 9cb3efd75..a66260207 100644 --- a/src/Model/MethodGroupGo.cs +++ b/src/Model/MethodGroupGo.cs @@ -89,6 +89,8 @@ internal void Transform(CodeModelGo cmg) var imports = new HashSet(); imports.UnionWith(CodeNamerGo.Instance.AutorestImports); imports.UnionWith(CodeNamerGo.Instance.StandardImports); + imports.UnionWith(CodeNamerGo.Instance.TracingImports); + cmg.Methods.Where(m => m.Group.Value == Name) .ForEach(m => @@ -96,7 +98,7 @@ internal void Transform(CodeModelGo cmg) var mg = m as MethodGo; if ((CodeModel as CodeModelGo).ShouldValidate && !mg.ParameterValidations.IsNullOrEmpty()) { - imports.UnionWith(CodeNamerGo.Instance.ValidationImport); + imports.UnionWith(CodeNamerGo.Instance.ValidationImports); } mg.ParametersGo.ForEach(p => p.AddImports(imports)); if (mg.HasReturnValue() && !mg.ReturnValue().Body.PrimaryType(KnownPrimaryType.Stream)) diff --git a/src/Model/PageTypeGo.cs b/src/Model/PageTypeGo.cs index 43f61bf26..390841125 100644 --- a/src/Model/PageTypeGo.cs +++ b/src/Model/PageTypeGo.cs @@ -99,9 +99,14 @@ public PageTypeGo(MethodGo method) : base(CodeNamerGo.Instance.GetPageTypeName(m /// public string ResultFieldName => ContentType.Name.ToVariableName(); + /// + /// The qualified name for the advancer method. + /// + public string AdvancerQualifiedName => $"{Name}.NextWithContext"; + public override string Fields() { - return $" {FnFieldName} func({ContentType.Name}) ({ContentType.Name}, error)\n {ResultFieldName} {ContentType.Name}"; + return $" {FnFieldName} func(context.Context, {ContentType.Name}) ({ContentType.Name}, error)\n {ResultFieldName} {ContentType.Name}"; } public override bool Equals(object other) diff --git a/src/Templates/MethodTemplate.cshtml b/src/Templates/MethodTemplate.cshtml index cb3a990a8..a50e86f6d 100644 --- a/src/Templates/MethodTemplate.cshtml +++ b/src/Templates/MethodTemplate.cshtml @@ -35,38 +35,64 @@ } func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@Model.MethodReturnSignature()) { -@if ((Model.CodeModel as CodeModelGo).ShouldValidate && !Model.ParameterValidations.IsNullOrEmpty()) -{ - - if err := validation.Validate([]validation.Validation{ - @(Model.ParameterValidations)}); err != nil { - return result, @(Model.ValidationError) - } - @EmptyLine - -} -@if (Model.IsPageable && !Model.IsLongRunningOperation() && !Model.IsNextMethod) -{ - var fnField = Model.ReturnType.Body.Cast().UnwrapPageType().FnFieldName; - var nextMethod = Model.NextMethod; - if (nextMethod != null) + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn + "/@(Model.QualifiedName)") + defer func() { + sc := -1 + @if (Model.IsLongRunningOperation()) { - var returnType = nextMethod.MethodReturnType; - var nextLinkField = Model.ReturnType.Body.Cast().UnwrapPageType().NextLink; - result.@fnField = func(lastResult @returnType) (@returnType, error) { - if lastResult.@nextLinkField == nil || len(to.String(lastResult.@nextLinkField)) < 1 { - return @returnType{}, nil - } - return client.@(nextMethod.Name)( @Model.NextMethodInvocationParameters($"*lastResult.{nextLinkField}") ) - } + if result.Response() != nil { + sc = result.Response().StatusCode + } } else { - @:result.@fnField = client.@(Model.NextMethodName) + var rawResponse = Model.HasReturnValue() ? $"{Model.ResponseAssignTarget}.Response.Response" : $"{Model.ResponseAssignTarget}.Response"; + + + if @(rawResponse) != nil { + sc = @(rawResponse).StatusCode + } + + } + + tracing.EndSpan(ctx, sc, err) + }() + } + @if ((Model.CodeModel as CodeModelGo).ShouldValidate && !Model.ParameterValidations.IsNullOrEmpty()) + { + + if err := validation.Validate([]validation.Validation{ + @(Model.ParameterValidations)}); err != nil { + return result, @(Model.ValidationError) + } + @EmptyLine + + } + @if (Model.IsPageable && !Model.IsLongRunningOperation() && !Model.IsNextMethod) + { + var fnField = Model.ReturnType.Body.Cast().UnwrapPageType().FnFieldName; + var nextMethod = Model.NextMethod; + if (nextMethod != null) + { + var returnType = nextMethod.MethodReturnType; + var nextLinkField = Model.ReturnType.Body.Cast().UnwrapPageType().NextLink; + + result.@fnField = func(ctx context.Context, lastResult @returnType) (@returnType, error) { + if lastResult.@nextLinkField == nil || len(to.String(lastResult.@nextLinkField)) < 1 { + return @returnType{}, nil + } + return client.@(nextMethod.Name)( @Model.NextMethodInvocationParameters($"*lastResult.{nextLinkField}") ) + } + + } + else + { + @:result.@fnField = client.@(Model.NextMethodName) + } } -} req, err := client.@(Model.PreparerMethodName)(@(Model.HelperInvocationParameters())) if err != nil { err = @(Model.AutorestError("Failure preparing request")) @@ -76,27 +102,27 @@ func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@M @if (Model.IsLongRunningOperation()) { - result, err = client.@(Model.SenderMethodName)(req) - if err != nil { - err = @(Model.AutorestError("Failure sending request", "result.Response()")) - return - } + result, err = client.@(Model.SenderMethodName)(req) + if err != nil { + err = @(Model.AutorestError("Failure sending request", "result.Response()")) + return + } } else { - resp, err := client.@(Model.SenderMethodName)(req) - if err != nil { - @(Model.Response(false)) - err = @(Model.AutorestError("Failure sending request", "resp")) - return - } - @EmptyLine - @(Model.ResponseAssignTarget), err = client.@(Model.ResponderMethodName)(resp) - if err != nil { - err = @(Model.AutorestError("Failure responding to request", "resp")) - } + resp, err := client.@(Model.SenderMethodName)(req) + if err != nil { + @(Model.Response(false)) + err = @(Model.AutorestError("Failure sending request", "resp")) + return + } + @EmptyLine + @(Model.ResponseAssignTarget), err = client.@(Model.ResponderMethodName)(resp) + if err != nil { + err = @(Model.AutorestError("Failure responding to request", "resp")) + } } @EmptyLine @@ -104,24 +130,24 @@ func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@M } @EmptyLine -@if (Model.Deprecated) -{ - @:@WrapComment("// Deprecated: ", depMessage) -} + @if (Model.Deprecated) + { + @:@WrapComment("// Deprecated: ", depMessage) + } // @(Model.PreparerMethodName) prepares the @(Model.Name) request. func (client @(Model.Owner)) @(Model.PreparerMethodName)(@(Model.MethodParametersSignature)) (*http.Request, error) { @if (Model.IsCustomBaseUri && Model.URLParameters.Any()) { - @(Model.URLMap) - @EmptyLine + @(Model.URLMap) + @EmptyLine } @if (Model.PathParameters.Any()) { - @(Model.PathMap) - @EmptyLine + @(Model.PathMap) + @EmptyLine } @if (Model.QueryParameters.Any()) @@ -138,7 +164,7 @@ func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@M @:@(p.AddToMap("queryParameters")) if (p.DefaultValue.Value != null) { - @:} else { + @:} else { @:@(p.AddToMap("queryParameters", useDefaultValue: true)) } @:} @@ -149,53 +175,53 @@ func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@M @if (Model.FormDataParameters.Any()) { - @(Model.FormDataMap) - @foreach (var p in Model.OptionalFormDataParameters) - { - @:if @(p.GetEmptyCheck(p.GetParameterName(), false)) { - @:@(p.AddToMap("formDataParameters")) - if (p.DefaultValue.Value != null) + @(Model.FormDataMap) + @foreach (var p in Model.OptionalFormDataParameters) { - @:} else { - @:@(p.AddToMap("formDataParameters", useDefaultValue: true)) + @:if @(p.GetEmptyCheck(p.GetParameterName(), false)) { + @:@(p.AddToMap("formDataParameters")) + if (p.DefaultValue.Value != null) + { + @:} else { + @:@(p.AddToMap("formDataParameters", useDefaultValue: true)) + } + @:} } - @:} - } - @EmptyLine + @EmptyLine } preparer := autorest.CreatePreparer( @(Model.PrepareDecorators.EmitAsArguments())) -@if (Model.BodyParameter != null && !Model.BodyParameter.IsRequired) -{ - var bodyParam = string.Format(Model.BodyParameter.ModelType.PrimaryType(KnownPrimaryType.Stream) - ? "autorest.WithFile({0})" - : "autorest.WithJSON({0})", - Model.BodyParameter.Name); - - if @(Model.BodyParameter.GetEmptyCheck(Model.BodyParameter.Name, false)) { - preparer = autorest.DecoratePreparer(preparer, - @(bodyParam)) - } - -} + @if (Model.BodyParameter != null && !Model.BodyParameter.IsRequired) + { + var bodyParam = string.Format(Model.BodyParameter.ModelType.PrimaryType(KnownPrimaryType.Stream) + ? "autorest.WithFile({0})" + : "autorest.WithJSON({0})", + Model.BodyParameter.Name); + + if @(Model.BodyParameter.GetEmptyCheck(Model.BodyParameter.Name, false)) { + preparer = autorest.DecoratePreparer(preparer, + @(bodyParam)) + } + + } @foreach (var p in Model.OptionalHeaderParameters) { - if @(p.GetEmptyCheck(p.GetParameterName(), false)) { - preparer = autorest.DecoratePreparer(preparer, - @(string.Format("autorest.WithHeader(\"{0}\",autorest.String({1}))", - p.SerializedName, p.GetParameterName()))) - @if (p.DefaultValue.Value != null) - { - @: } else { - @:preparer = autorest.DecoratePreparer(preparer, - @:@(string.Format("autorest.WithHeader(\"{0}\",autorest.String({1}))", - p.SerializedName, p.DefaultValueString))) - } - } + if @(p.GetEmptyCheck(p.GetParameterName(), false)) { + preparer = autorest.DecoratePreparer(preparer, + @(string.Format("autorest.WithHeader(\"{0}\",autorest.String({1}))", + p.SerializedName, p.GetParameterName()))) + @if (p.DefaultValue.Value != null) + { + @: } else { + @:preparer = autorest.DecoratePreparer(preparer, + @:@(string.Format("autorest.WithHeader(\"{0}\",autorest.String({1}))", + p.SerializedName, p.DefaultValueString))) + } + } } @@ -211,63 +237,63 @@ func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@M } @EmptyLine -@if (Model.Deprecated) -{ - @:@WrapComment("// Deprecated: ", depMessage) -} + @if (Model.Deprecated) + { + @:@WrapComment("// Deprecated: ", depMessage) + } // @(Model.SenderMethodName) sends the @(Model.Name) request. The method will close the // http.Response Body if it receives an error. func (client @(Model.Owner)) @(Model.SenderMethodName)(req *http.Request) (@senderRetSig) { @if (Model.IsLongRunningOperation()) { - var resp *http.Response - resp, err = autorest.SendWithSender(client, req, + var resp *http.Response + resp, err = autorest.SendWithSender(client, req, @(Model.SendDecorators.EmitAsArguments())) - if err != nil { + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return } else { - return autorest.SendWithSender(client, req, - @(Model.SendDecorators.EmitAsArguments())) + return autorest.SendWithSender(client, req, + @(Model.SendDecorators.EmitAsArguments())) } } - @EmptyLine +@EmptyLine @if (Model.Deprecated) { @:@WrapComment("// Deprecated: ", depMessage) } - // @(Model.ResponderMethodName) handles the response to the @(Model.Name) request. The method always - // closes the http.Response Body. - func (client @(Model.Owner)) @(Model.ResponderMethodName)(resp *http.Response) (@Model.ResponderReturnSignature()) { +// @(Model.ResponderMethodName) handles the response to the @(Model.Name) request. The method always +// closes the http.Response Body. +func (client @(Model.Owner)) @(Model.ResponderMethodName)(resp *http.Response) (@Model.ResponderReturnSignature()) { @if (Model.IsLongRunningOperation() && Model.IsPageable) { var pageType = Model.ReturnType.Body.Cast().UnwrapPageType(); - - result.@(pageType.ResultFieldName), err = client.@(Model.ResponderMethodName.ToCamelCase())(resp) - result.@(pageType.FnFieldName) = client.@(Model.NextMethodName) - + + result.@(pageType.ResultFieldName), err = client.@(Model.ResponderMethodName.ToCamelCase())(resp) + result.@(pageType.FnFieldName) = client.@(Model.NextMethodName) + } else { - + @if (Model.ReturnValue().Body.IsStreamType()) { - @:result.Value = &resp.Body + @:result.Value = &resp.Body } - err = autorest.Respond( - @(Model.RespondDecorators.EmitAsArguments())) + err = autorest.Respond( + @(Model.RespondDecorators.EmitAsArguments())) - @(Model.Response(true)) - + @(Model.Response(true)) + } return } @@ -276,18 +302,18 @@ func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@M { var pageType = Model.ReturnType.Body.Cast().UnwrapPageType(); - @EmptyLine - func (client @(Model.Owner)) @(Model.ResponderMethodName.ToCamelCase())(resp *http.Response) (result @pageType.ContentType.Name, err error) { - @if (Model.ReturnValue().Body.IsStreamType()) - { - @:result.Value = &resp.Body - } - err = autorest.Respond( - @(Model.RespondDecorators.EmitAsArguments())) + @EmptyLine + func (client @(Model.Owner)) @(Model.ResponderMethodName.ToCamelCase())(resp *http.Response) (result @pageType.ContentType.Name, err error) { + @if (Model.ReturnValue().Body.IsStreamType()) + { + @:result.Value = &resp.Body + } + err = autorest.Respond( + @(Model.RespondDecorators.EmitAsArguments())) - @(Model.Response(true)) - return - } + @(Model.Response(true)) + return + } } @@ -299,31 +325,31 @@ func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@M preparerName = $"{Model.LastResultsTypeName().ToCamelCase()}Preparer"; } - @EmptyLine - // @(Model.NextMethodName) retrieves the next set of results, if any. - func (client @(Model.Owner)) @(Model.NextMethodName)(lastResults @Model.LastResultsTypeName()) (@Model.NextMethodReturnSignature()) { - req, err := lastResults.@(preparerName)() - if err != nil { - return result, @(Model.AutorestError("Failure preparing next results request", null, null, Model.NextMethodName)) - } - if req == nil { - return - } - @if (Model.IsLongRunningOperation()) - { - - var resp *http.Response - resp, err = autorest.SendWithSender(client, req, - autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + @EmptyLine + // @(Model.NextMethodName) retrieves the next set of results, if any. + func (client @(Model.Owner)) @(Model.NextMethodName)(ctx context.Context, lastResults @Model.LastResultsTypeName()) (@Model.NextMethodReturnSignature()) { + req, err := lastResults.@(preparerName)(ctx) if err != nil { - return result, @(Model.AutorestError("Failure sending next results request", "resp", null, Model.NextMethodName)) + return result, @(Model.AutorestError("Failure preparing next results request", null, null, Model.NextMethodName)) } - return client.@(Model.ResponderMethodName.ToCamelCase())(resp) - - } - else - { - + if req == nil { + return + } + @if (Model.IsLongRunningOperation()) + { + + var resp *http.Response + resp, err = autorest.SendWithSender(client, req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if err != nil { + return result, @(Model.AutorestError("Failure sending next results request", "resp", null, Model.NextMethodName)) + } + return client.@(Model.ResponderMethodName.ToCamelCase())(resp) + + } + else + { + resp, err := client.@(Model.SenderMethodName)(req) if err != nil { @(Model.Response(true)) @@ -334,38 +360,66 @@ func (client @(Model.Owner)) @(Model.Name)(@Model.MethodParametersSignature) (@M err = @(Model.AutorestError("Failure responding to next results request", "resp", null, Model.NextMethodName)) } return + + } + } - } - } +} + +@if (Model.IsPageable && !Model.IsNextMethod) +{ + var resultTypeName = Model.ReturnType.Body.Cast().UnwrapPageType().IteratorType.Name; + var pageType = Model.ReturnType.Body.Cast().UnwrapPageType(); + + if (Model.IsLongRunningOperation()) + { + resultTypeName = ((LroPagedResponseGo)Model.ReturnType).ListAllReturnType.Name; + } + + @EmptyLine + // @(Model.ListCompleteMethodName) enumerates all values, automatically crossing page boundaries as required. + func (client @(Model.Owner)) @(Model.ListCompleteMethodName)(@(Model.MethodParametersSignature)) (result @resultTypeName, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn + "/@(Model.QualifiedName)") + + defer func() { + sc := -1 + + @if (Model.IsLongRunningOperation()) + { + + if result.Response() != nil { + sc = result.Response().StatusCode + } + + } + else + { + + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } } - @if (Model.IsPageable && !Model.IsNextMethod) + tracing.EndSpan(ctx, sc, err) + }() + } + @if (Model.IsLongRunningOperation()) { - var resultTypeName = Model.ReturnType.Body.Cast().UnwrapPageType().IteratorType.Name; - if (Model.IsLongRunningOperation()) - { - resultTypeName = ((LroPagedResponseGo)Model.ReturnType).ListAllReturnType.Name; - } - @EmptyLine - // @(Model.ListCompleteMethodName) enumerates all values, automatically crossing page boundaries as required. - func (client @(Model.Owner)) @(Model.ListCompleteMethodName)(@(Model.MethodParametersSignature)) (result @resultTypeName, err error) { - @if (Model.IsLongRunningOperation()) - { - - var future @Model.MethodReturnType - future, err = client.@(Model.Name)(@(Model.HelperInvocationParameters())) - result.Future = future.Future - - } - else - { - - result.page, err = client.@(Model.Name)(@(Model.HelperInvocationParameters())) - - } - return - } + var future @Model.MethodReturnType + future, err = client.@(Model.Name)(@(Model.HelperInvocationParameters())) + result.Future = future.Future + + } + else + { + + result.page, err = client.@(Model.Name)(@(Model.HelperInvocationParameters())) } + return + } + +} diff --git a/src/Templates/ModelTemplate.cshtml b/src/Templates/ModelTemplate.cshtml index 8bf93154a..4a462113e 100644 --- a/src/Templates/ModelTemplate.cshtml +++ b/src/Templates/ModelTemplate.cshtml @@ -19,127 +19,127 @@ { @if (Model.Deprecated) { - @:@WrapComment("// Deprecated: ", depMessage) + @:@WrapComment("// Deprecated: ", depMessage) } @WrapComment("// ", $"{Model.GetInterfaceName()} {Model.Documentation.ToSentence()}") - type @(Model.GetInterfaceName()) interface { - @foreach (var dt in Model.DerivedTypes) - { - @:As@(dt.Name) () (*@(dt.Name), bool) - if (dt.HasInterface()) + type @(Model.GetInterfaceName()) interface { + @foreach (var dt in Model.DerivedTypes) { - @:As@(dt.GetInterfaceName()) () (@(dt.GetInterfaceName()), bool) + @:As@(dt.Name) () (*@(dt.Name), bool) + if (dt.HasInterface()) + { + @:As@(dt.GetInterfaceName()) () (@(dt.GetInterfaceName()), bool) + } + } + As@(Model.Name) () (*@(Model.Name), bool) } - } - As@(Model.Name) () (*@(Model.Name), bool) - } - - @EmptyLine - @if (Model.Deprecated) - { - @:@WrapComment("// Deprecated: ", depMessage) - } - @WrapComment("// ", $"{Model.Name} {Model.Documentation.ToSentence()}") - type @(Model.Name) struct { - @(Model.AddHTTPResponse()) - @(Model.Fields()) - } - @EmptyLine - func unmarshal@(Model.GetInterfaceName())(body []byte) (@(Model.GetInterfaceName()), error){ - var m map[string]interface{} - err := json.Unmarshal(body, &m) - if err != nil { - return nil, err - } - @EmptyLine - switch m["@(Model.RootType.PolymorphicDiscriminator)"] { - @foreach (var dt in Model.DerivedTypes) - { - - case string(@(CodeNamerGo.Instance.GetEnumMemberName((dt as CompositeTypeGo).DiscriminatorEnumValue))): - var @(dt.Name.FixedValue.ToVariableName()) @(dt.Name) - err := json.Unmarshal(body, &@(dt.Name.FixedValue.ToVariableName())) - return @(dt.Name.FixedValue.ToVariableName()), err - - } - default: - var @(Model.Name.FixedValue.ToVariableName()) @(Model.Name) - err := json.Unmarshal(body, &@(Model.Name.FixedValue.ToVariableName())) - return @(Model.Name.FixedValue.ToVariableName()), err - } - } + @EmptyLine + @if (Model.Deprecated) + { + @:@WrapComment("// Deprecated: ", depMessage) + } + @WrapComment("// ", $"{Model.Name} {Model.Documentation.ToSentence()}") + type @(Model.Name) struct { + @(Model.AddHTTPResponse()) + @(Model.Fields()) + } - func unmarshal@(Model.GetInterfaceName())Array(body []byte) ([]@(Model.GetInterfaceName()), error){ - var rawMessages []*json.RawMessage - err := json.Unmarshal(body, &rawMessages) - if err != nil { - return nil, err - } - @EmptyLine - @(Model.Name.FixedValue.ToVariableName())Array := make([]@(Model.GetInterfaceName()), len(rawMessages)) - @EmptyLine - for index, rawMessage := range rawMessages { - @(Model.Name.FixedValue.ToVariableName()), err := unmarshal@(Model.GetInterfaceName())(*rawMessage) - if err != nil { - return nil, err - } - @(Model.Name.FixedValue.ToVariableName())Array[index] = @(Model.Name.FixedValue.ToVariableName()) - } - return @(Model.Name.FixedValue.ToVariableName())Array, nil - } + @EmptyLine + func unmarshal@(Model.GetInterfaceName())(body []byte) (@(Model.GetInterfaceName()), error){ + var m map[string]interface{} + err := json.Unmarshal(body, &m) + if err != nil { + return nil, err + } + @EmptyLine + switch m["@(Model.RootType.PolymorphicDiscriminator)"] { + @foreach (var dt in Model.DerivedTypes) + { + + case string(@(CodeNamerGo.Instance.GetEnumMemberName((dt as CompositeTypeGo).DiscriminatorEnumValue))): + var @(dt.Name.FixedValue.ToVariableName()) @(dt.Name) + err := json.Unmarshal(body, &@(dt.Name.FixedValue.ToVariableName())) + return @(dt.Name.FixedValue.ToVariableName()), err } -else -{ - if (Model is PageTypeGo) - { - var pageType = Model as PageTypeGo; - var itemName = pageType.ItemName; - var contentType = pageType.ContentType.Name; - var receiverVar = contentType.FixedValue.ToVariableName(); + default: + var @(Model.Name.FixedValue.ToVariableName()) @(Model.Name) + err := json.Unmarshal(body, &@(Model.Name.FixedValue.ToVariableName())) + return @(Model.Name.FixedValue.ToVariableName()), err + } + } - - @EmptyLine - // IsEmpty returns true if the ListResult contains no values. - func (@receiverVar @contentType) IsEmpty() bool { - return @(receiverVar).@itemName == nil || len(*@(receiverVar).@itemName) == 0 + func unmarshal@(Model.GetInterfaceName())Array(body []byte) ([]@(Model.GetInterfaceName()), error){ + var rawMessages []*json.RawMessage + err := json.Unmarshal(body, &rawMessages) + if err != nil { + return nil, err } @EmptyLine + @(Model.Name.FixedValue.ToVariableName())Array := make([]@(Model.GetInterfaceName()), len(rawMessages)) + @EmptyLine + for index, rawMessage := range rawMessages { + @(Model.Name.FixedValue.ToVariableName()), err := unmarshal@(Model.GetInterfaceName())(*rawMessage) + if err != nil { + return nil, err + } + @(Model.Name.FixedValue.ToVariableName())Array[index] = @(Model.Name.FixedValue.ToVariableName()) + } + return @(Model.Name.FixedValue.ToVariableName())Array, nil + } - if (pageType.PreparerNeeded) + } + else + { + if (Model is PageTypeGo) { + var pageType = Model as PageTypeGo; + var itemName = pageType.ItemName; + var contentType = pageType.ContentType.Name; + var receiverVar = contentType.FixedValue.ToVariableName(); + - // @(pageType.PreparerMethodName) prepares a request to retrieve the next set of results. - // It returns nil if no more results exist. - func (@receiverVar @contentType) @(pageType.PreparerMethodName)() (*http.Request, error) { - if @(receiverVar).@(pageType.NextLink) == nil || len(to.String(@(receiverVar).@(pageType.NextLink))) < 1 { - return nil, nil - } - return autorest.Prepare(&http.Request{}, - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String( @(receiverVar).@(pageType.NextLink)))); - } - @EmptyLine + @EmptyLine + // IsEmpty returns true if the ListResult contains no values. + func (@receiverVar @contentType) IsEmpty() bool { + return @(receiverVar).@itemName == nil || len(*@(receiverVar).@itemName) == 0 + } + @EmptyLine + if (pageType.PreparerNeeded) + { + + // @(pageType.PreparerMethodName) prepares a request to retrieve the next set of results. + // It returns nil if no more results exist. + func (@receiverVar @contentType) @(pageType.PreparerMethodName)(ctx context.Context) (*http.Request, error) { + if @(receiverVar).@(pageType.NextLink) == nil || len(to.String(@(receiverVar).@(pageType.NextLink))) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String( @(receiverVar).@(pageType.NextLink)))); + } + @EmptyLine + + } } + + @if (Model.Deprecated) + { + @:@WrapComment("// Deprecated: ", depMessage) + } + @WrapComment("// ", $"{Model.Name} {Model.Documentation.ToSentence()}") + type @(Model.Name) struct { + @(Model.AddHTTPResponse()) + @(Model.Fields()) + } + } - - @if (Model.Deprecated) - { - @:@WrapComment("// Deprecated: ", depMessage) - } - @WrapComment("// ", $"{Model.Name} {Model.Documentation.ToSentence()}") - type @(Model.Name) struct { - @(Model.AddHTTPResponse()) - @(Model.Fields()) - } - -} -@if (Model.BaseIsPolymorphic || Model.IsPolymorphic || Model.HasFlattenedFields || Model.AllProperties.Any(p => p.ModelType is DictionaryTypeGo)) +@if (Model.BaseIsPolymorphic || Model.IsPolymorphic || Model.HasFlattenedFields || Model.AllProperties.Any(p => p.ModelType is DictionaryTypeGo)) { @EmptyLine @@ -148,9 +148,9 @@ else @if (Model.DiscriminatorEnumValue != null) { - @(Model.Name.FixedValue.ToVariableName()).@(Model.PolymorphicProperty) = @(CodeNamerGo.Instance.GetEnumMemberName(Model.DiscriminatorEnumValue)) - - } + @(Model.Name.FixedValue.ToVariableName()).@(Model.PolymorphicProperty) = @(CodeNamerGo.Instance.GetEnumMemberName(Model.DiscriminatorEnumValue)) + +} objectMap := make(map[string]interface{}) @foreach (var property in Model.AllProperties.Where(p => !string.IsNullOrEmpty(p.SerializedName))) @@ -180,34 +180,19 @@ else } return json.Marshal(objectMap) } - -} + + } @if (Model.BaseIsPolymorphic || Model.IsPolymorphic) { - @foreach (var st in Model.SiblingTypes) - { - - @EmptyLine - // As@(st.Name) is the @(Model.RootType.GetInterfaceName()) implementation for @(Model.Name). - func (@(Model.Name.FixedValue.ToVariableName()) @(Model.Name)) As@(st.Name)() (*@(st.Name), bool) { - @if (st.Equals(Model)) - { - @:return &@(Model.Name.FixedValue.ToVariableName()), true - } - else - { - @:return nil, false - } - } - - @if (st.HasInterface()) + @foreach (var st in Model.SiblingTypes) { + @EmptyLine - @:// As@(st.GetInterfaceName()) is the @(Model.RootType.GetInterfaceName()) implementation for @(Model.Name). - @:func(@(Model.Name.FixedValue.ToVariableName()) @(Model.Name)) As@(st.GetInterfaceName())()(@(st.GetInterfaceName()), bool) { - if (st.Equals(Model) || Model.DerivesFrom(st)) + // As@(st.Name) is the @(Model.RootType.GetInterfaceName()) implementation for @(Model.Name). + func (@(Model.Name.FixedValue.ToVariableName()) @(Model.Name)) As@(st.Name)() (*@(st.Name), bool) { + @if (st.Equals(Model)) { @:return &@(Model.Name.FixedValue.ToVariableName()), true } @@ -215,51 +200,66 @@ else { @:return nil, false } - @:} - @EmptyLine - } - - } + } + + @if (st.HasInterface()) + { + @EmptyLine + @:// As@(st.GetInterfaceName()) is the @(Model.RootType.GetInterfaceName()) implementation for @(Model.Name). + @:func(@(Model.Name.FixedValue.ToVariableName()) @(Model.Name)) As@(st.GetInterfaceName())()(@(st.GetInterfaceName()), bool) { + if (st.Equals(Model) || Model.DerivesFrom(st)) + { + @:return &@(Model.Name.FixedValue.ToVariableName()), true + } + else + { + @:return nil, false + } + @:} + @EmptyLine + } } + + } @if (Model.NeedsCustomMarshalling) { var vsp = new VariableScopeProvider(); var receiverVar = Model.Name.FixedValue.ToVariableName(vsp); - // UnmarshalJSON is the custom unmarshaler for @(Model.Name) struct. - func (@receiverVar *@(Model.Name)) UnmarshalJSON(@(vsp.GetVariableName("body")) []byte) error { - @if (Model.IsWrapperType) - { - string varName; - if (Model.BaseType is SequenceTypeGo sequenceType) - { - varName = sequenceType.ElementType.Name.FixedValue.ToVariableName(vsp); - @:@varName, err := unmarshal@(sequenceType.ElementType.GetInterfaceName())Array(body) - } - else - { - varName = Model.BaseType.Name.FixedValue.ToVariableName(vsp); - @:@varName, err := unmarshal@(Model.BaseType.GetInterfaceName())(body) - } - - if err != nil { - return err - } - - if (Model.BaseType is SequenceType type) + // UnmarshalJSON is the custom unmarshaler for @(Model.Name) struct. + func (@receiverVar *@(Model.Name)) UnmarshalJSON(@(vsp.GetVariableName("body")) []byte) error { + @if (Model.IsWrapperType) { - @:@(receiverVar).Value = &@varName - } - else - { - @:@(receiverVar).Value = @varName - } + string varName; + if (Model.BaseType is SequenceTypeGo sequenceType) + { + varName = sequenceType.ElementType.Name.FixedValue.ToVariableName(vsp); + @:@varName, err := unmarshal@(sequenceType.ElementType.GetInterfaceName())Array(body) + } + else + { + varName = Model.BaseType.Name.FixedValue.ToVariableName(vsp); + @:@varName, err := unmarshal@(Model.BaseType.GetInterfaceName())(body) + } + + if err != nil { + return err + } + + if (Model.BaseType is SequenceType type) + { + @:@(receiverVar).Value = &@varName } else { - + @:@(receiverVar).Value = @varName + } +} +else +{ + var m map[string]*json.RawMessage err := json.Unmarshal(body, &m) if err != nil { @@ -276,110 +276,127 @@ else { case "@(p.SerializedName)": - - } - else - { - - default: - - } - - var modelType = p.ModelType; + +} +else +{ + + default: + +} - if (modelType is DictionaryTypeGo dictionaryType && dictionaryType.SupportsAdditionalProperties) - { - modelType = dictionaryType.ValueType; - } - - if v != nil { - @if (modelType.HasInterface()) - { - @:@varName, err := unmarshal@(modelType.GetInterfaceName())(*v) - } - else if (modelType is SequenceTypeGo sequenceType && sequenceType.ElementType.HasInterface()) - { - @:@varName, err := unmarshal@(sequenceType.ElementType.GetInterfaceName())Array(*v) - } - else - { - - var @varName @(modelType.Name) - err = json.Unmarshal(*v, &@varName) - - } - if err != nil { - return err - } - @if (p.ModelType is DictionaryTypeGo type && type.SupportsAdditionalProperties) - { - @:if(@(receiverVar).@(p.Name) == nil) { - @: @(receiverVar).@(p.Name) = make(@(p.ModelType.Name)) - @:} - if (type.ValueType.CanBeNull()) - { - @:@(receiverVar).@(p.Name)[k] = @varName - } - else - { - @:@(receiverVar).@(p.Name)[k] = &@varName - } - } - else if (!p.IsPointer) - { - @:@(receiverVar).@(p.Name) = @varName - } - else - { - @:@(receiverVar).@(p.Name) = &@varName - } - } +var modelType = p.ModelType; - - } +if (modelType is DictionaryTypeGo dictionaryType && dictionaryType.SupportsAdditionalProperties) +{ + modelType = dictionaryType.ValueType; +} + + if v != nil { + @if (modelType.HasInterface()) + { + @:@varName, err := unmarshal@(modelType.GetInterfaceName())(*v) + } + else if (modelType is SequenceTypeGo sequenceType && sequenceType.ElementType.HasInterface()) + { + @:@varName, err := unmarshal@(sequenceType.ElementType.GetInterfaceName())Array(*v) + } + else + { + + var @varName @(modelType.Name) + err = json.Unmarshal(*v, &@varName) + +} + if err != nil { + return err + } + @if (p.ModelType is DictionaryTypeGo type && type.SupportsAdditionalProperties) + { + @:if(@(receiverVar).@(p.Name) == nil) { + @: @(receiverVar).@(p.Name) = make(@(p.ModelType.Name)) + @:} + if (type.ValueType.CanBeNull()) + { + @:@(receiverVar).@(p.Name)[k] = @varName } + else + { + @:@(receiverVar).@(p.Name)[k] = &@varName } - } - @EmptyLine - return nil + else if (!p.IsPointer) + { + @:@(receiverVar).@(p.Name) = @varName + } + else + { + @:@(receiverVar).@(p.Name) = &@varName + } } + } + } + } + + } + @EmptyLine + return nil + } + + } @if (Model is PageTypeGo modelPageType) { var itemName = modelPageType.ItemName; - @EmptyLine - // Next advances to the next page of values. If there was an error making - // the request the page does not advance and the error is returned. - func (page * @Model.Name) Next() error { - next, err := page.@(modelPageType.FnFieldName)(page.@modelPageType.ResultFieldName) - if err != nil { - return err - } - page.@modelPageType.ResultFieldName = next - return nil - } + @EmptyLine + // NextWithContext advances to the next page of values. If there was an error making + // the request the page does not advance and the error is returned. + func (page * @Model.Name) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn + "/@(modelPageType.AdvancerQualifiedName)") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.@(modelPageType.FnFieldName)(ctx, page.@modelPageType.ResultFieldName) + if err != nil { + return err + } + page.@modelPageType.ResultFieldName = next + return nil + } + @EmptyLine + // Next advances to the next page of values. If there was an error making + // the request the page does not advance and the error is returned. + @WrapComment("// Deprecated: ", "Use NextWithContext() instead.") + func (page * @Model.Name) Next() error { + return page.NextWithContext(context.Background()) + } - // NotDone returns true if the page enumeration should be started or is not yet complete. - func (page @Model.Name) NotDone() bool { - return !page.@(modelPageType.ResultFieldName).IsEmpty() - } + // NotDone returns true if the page enumeration should be started or is not yet complete. + func (page @Model.Name) NotDone() bool { + return !page.@(modelPageType.ResultFieldName).IsEmpty() + } - // Response returns the raw server response from the last page request. - func (page @Model.Name) Response() @modelPageType.ContentType.Name { - return page.@modelPageType.ResultFieldName - } + // Response returns the raw server response from the last page request. + func (page @Model.Name) Response() @modelPageType.ContentType.Name { + return page.@modelPageType.ResultFieldName + } - // Values returns the slice of values for the current page or nil if there are no values. - func (page @Model.Name) Values() []@(modelPageType.ReturnTypeName) { - if page.@(modelPageType.ResultFieldName).IsEmpty() { - return nil - } - return *page.@(modelPageType.ResultFieldName).@itemName - } + // Values returns the slice of values for the current page or nil if there are no values. + func (page @Model.Name) Values() []@(modelPageType.ReturnTypeName) { + if page.@(modelPageType.ResultFieldName).IsEmpty() { + return nil + } + return *page.@(modelPageType.ResultFieldName).@itemName + } } @@ -388,40 +405,56 @@ else var itemType = iterType.PageType.ElementType; var itemTypeName = iterType.PageType.ReturnTypeName; - // Next advances to the next value. If there was an error making - // the request the iterator does not advance and the error is returned. - func (iter * @Model.Name) Next() error { - iter.@iterType.IndexField++ - if iter.@iterType.IndexField < len(iter. @(iterType.PageField).Values()) { - return nil - } - err := iter.@(iterType.PageField).Next() - if err != nil { - iter. @iterType.IndexField-- - return err - } - iter.@iterType.IndexField = 0 - return nil - } + // NextWithContext advances to the next value. If there was an error making + // the request the iterator does not advance and the error is returned. + func (iter * @Model.Name) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn + "/@(iterType.AdvancerQualifiedName)") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.@iterType.IndexField++ + if iter.@iterType.IndexField < len(iter. @(iterType.PageField).Values()) { + return nil + } + err = iter.@(iterType.PageField).NextWithContext(ctx) + if err != nil { + iter. @iterType.IndexField-- + return err + } + iter.@iterType.IndexField = 0 + return nil + } - // NotDone returns true if the enumeration should be started or is not yet complete. - func (iter @Model.Name) NotDone() bool { - return iter.@(iterType.PageField).NotDone() && iter.@iterType.IndexField < len(iter. @(iterType.PageField).Values()) - } + // Next advances to the next value. If there was an error making + // the request the iterator does not advance and the error is returned. + @WrapComment("// Deprecated: ", "Use NextWithContext() instead.") + func (iter * @Model.Name) Next() error { + return iter.NextWithContext(context.Background()) + } + // NotDone returns true if the enumeration should be started or is not yet complete. + func (iter @Model.Name) NotDone() bool { + return iter.@(iterType.PageField).NotDone() && iter.@iterType.IndexField < len(iter. @(iterType.PageField).Values()) + } - // Response returns the raw server response from the last page request. - func (iter @Model.Name) Response() @iterType.PageType.ContentType.Name { - return iter.@(iterType.PageField).Response() - } + // Response returns the raw server response from the last page request. + func (iter @Model.Name) Response() @iterType.PageType.ContentType.Name { + return iter.@(iterType.PageField).Response() + } - // Value returns the current value or a zero-initialized value if the - // iterator has advanced beyond the end of the collection. - func (iter @Model.Name) Value() @(itemTypeName) { - if !iter.@(iterType.PageField).NotDone() { - return @itemType.GetZeroInitExpression() - } - return iter.@(iterType.PageField).Values()[iter.@iterType.IndexField] - } + // Value returns the current value or a zero-initialized value if the + // iterator has advanced beyond the end of the collection. + func (iter @Model.Name) Value() @(itemTypeName) { + if !iter.@(iterType.PageField).NotDone() { + return @itemType.GetZeroInitExpression() + } + return iter.@(iterType.PageField).Values()[iter.@iterType.IndexField] + } } @@ -436,41 +469,41 @@ else resultVarTarget = $"{resultVarTarget}.{ptg.ResultFieldName}"; } - // Result returns the result of the asynchronous operation. - // If the operation has not completed it will return an error. - func (future *@Model.Name) Result(client @ftg.ClientTypeName) (@resultVar @ftg.ResultTypeName, err error) { - var done bool - done, err = future.Done(client) - if err != nil { + // Result returns the result of the asynchronous operation. + // If the operation has not completed it will return an error. + func (future *@Model.Name) Result(client @ftg.ClientTypeName) (@resultVar @ftg.ResultTypeName, err error) { + var done bool + done, err = future.Done(client) + if err != nil { err = autorest.NewErrorWithError(err, "@futureTypeName", "Result", future.Response(), "Polling failure") return - } - if !done { + } + if !done { err = azure.NewAsyncOpIncompleteError("@futureTypeName") return - } - @if (ftg.IsDefaultReturnType) - { - // for default return types (i.e. autorest.Response) - // assign the raw HTTP response to the *http.Response field - @:@(resultVarTarget).Response = future.Response() - } - else - { - // modeled return types embed autorest.Resposne as an anonymous field - // so in order to assign the raw HTTP response to the *http.Response field - // in it we need an extra ".Response" :( - - sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) - if @(resultVarTarget).Response.Response, err = future.GetResult(sender); err == nil && @(resultVarTarget).Response.Response.StatusCode != http.StatusNoContent { - @resultVar, err = client.@(ftg.ResponderMethodName)(@(resultVarTarget).Response.Response) - if err != nil { - err = autorest.NewErrorWithError(err, "@futureTypeName", "Result", @(resultVarTarget).Response.Response, "Failure responding to request") } - } + @if (ftg.IsDefaultReturnType) + { + // for default return types (i.e. autorest.Response) + // assign the raw HTTP response to the *http.Response field + @:@(resultVarTarget).Response = future.Response() + } + else + { + // modeled return types embed autorest.Resposne as an anonymous field + // so in order to assign the raw HTTP response to the *http.Response field + // in it we need an extra ".Response" :( + + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if @(resultVarTarget).Response.Response, err = future.GetResult(sender); err == nil && @(resultVarTarget).Response.Response.StatusCode != http.StatusNoContent { + @resultVar, err = client.@(ftg.ResponderMethodName)(@(resultVarTarget).Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "@futureTypeName", "Result", @(resultVarTarget).Response.Response, "Failure responding to request") + } + } - } - return } - -} \ No newline at end of file + return + } + + } \ No newline at end of file diff --git a/src/Templates/ModelsTemplate.cshtml b/src/Templates/ModelsTemplate.cshtml index d4a37afc5..d2db65011 100644 --- a/src/Templates/ModelsTemplate.cshtml +++ b/src/Templates/ModelsTemplate.cshtml @@ -31,6 +31,10 @@ foreach (var import in Model.ModelImports) @EmptyLine } +// The package's fully qualified name. +const fqdn = "@(Model.PackageFqdn)" +@EmptyLine + @foreach (var e in enums) { @:@(Include(new EnumTemplate(), e)) diff --git a/test/src/tests/Gopkg.lock b/test/src/tests/Gopkg.lock index 1bbc4ae5a..cfc0a8e37 100644 --- a/test/src/tests/Gopkg.lock +++ b/test/src/tests/Gopkg.lock @@ -2,7 +2,15 @@ [[projects]] - digest = "1:71d4ad76bf664045779de0cc55856f59a0753acd0b099a1ae01dfa33f43995cf" + digest = "1:e1b859e3d9e90007d5fbf25edf57733b224f1857f6592636130afab3af8cfae7" + name = "contrib.go.opencensus.io/exporter/ocagent" + packages = ["."] + pruneopts = "" + revision = "00af367e65149ff1f2f4b93bbfbb84fd9297170d" + version = "v0.2.0" + +[[projects]] + digest = "1:bfacb70d8c34b1e883ea716a0175ba008291545c584b190ca246fb373ca086ea" name = "github.com/Azure/go-autorest" packages = [ "autorest", @@ -12,11 +20,24 @@ "autorest/to", "autorest/validation", "logger", + "tracing", "version", ] pruneopts = "" - revision = "4b7f49dc5db2e1e6d528524d269b4181981a7ebf" - version = "v11.1.1" + revision = "4492bbb1052f65ed4958bb2f2d37d472e96e7151" + version = "v11.2.0" + +[[projects]] + digest = "1:e0a4505d5cf7ac6b5d92e3aee79d838b5f1ae8e9641ec7fa5d1e9b01d7a7ea95" + name = "github.com/census-instrumentation/opencensus-proto" + packages = [ + "gen-go/agent/common/v1", + "gen-go/agent/trace/v1", + "gen-go/trace/v1", + ] + pruneopts = "" + revision = "24333298e36590ea0716598caacc8959fc393c48" + version = "v0.0.2" [[projects]] digest = "1:6098222470fe0172157ce9bbef5d2200df4edde17ee649c5d6e48330e4afa4c6" @@ -26,6 +47,21 @@ revision = "06ea1031745cb8b3dab3f6a236daf2b0aa468b7e" version = "v3.2.0" +[[projects]] + digest = "1:3dd078fda7500c341bc26cfbc6c6a34614f295a2457149fc1045cab767cbcf18" + name = "github.com/golang/protobuf" + packages = [ + "proto", + "ptypes", + "ptypes/any", + "ptypes/duration", + "ptypes/timestamp", + "ptypes/wrappers", + ] + pruneopts = "" + revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5" + version = "v1.2.0" + [[projects]] digest = "1:3108ec0946181c60040ff51b811908f89d03e521e2b4ade5ef5c65b3c0e911ae" name = "github.com/kr/pretty" @@ -58,6 +94,136 @@ revision = "cd690d0c9e2447b1ef2a129a6b7b49077da89b8e" version = "1.1.0" +[[projects]] + branch = "master" + digest = "1:823ae1db8fa98668e52990ee27a0509f5c5770f23f4afbc6f87a9ee5fbdea88a" + name = "go.opencensus.io" + packages = [ + ".", + "exemplar", + "internal", + "internal/tagencoding", + "plugin/ochttp", + "plugin/ochttp/propagation/b3", + "plugin/ochttp/propagation/tracecontext", + "stats", + "stats/internal", + "stats/view", + "tag", + "trace", + "trace/internal", + "trace/propagation", + "trace/tracestate", + ] + pruneopts = "" + revision = "1eb9a13c7dd02141e065a665f6bf5c99a090a16a" + +[[projects]] + branch = "master" + digest = "1:6543c75ddc1efc0041202dd49378ee2e5711b7cc82c2845c0437eef6276cc984" + name = "golang.org/x/net" + packages = [ + "context", + "http/httpguts", + "http2", + "http2/hpack", + "idna", + "internal/timeseries", + "trace", + ] + pruneopts = "" + revision = "04a2e542c03f1d053ab3e4d6e5abcd4b66e2be8e" + +[[projects]] + branch = "master" + digest = "1:b2ea75de0ccb2db2ac79356407f8a4cd8f798fe15d41b381c00abf3ae8e55ed1" + name = "golang.org/x/sync" + packages = ["semaphore"] + pruneopts = "" + revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca" + +[[projects]] + branch = "master" + digest = "1:2ed0bf267e44950120acd95570227e28184573ffb099bd85b529ee148e004ddb" + name = "golang.org/x/sys" + packages = ["unix"] + pruneopts = "" + revision = "fa43e7bc11baaae89f3f902b2b4d832b68234844" + +[[projects]] + digest = "1:5acd3512b047305d49e8763eef7ba423901e85d5dd2fd1e71778a0ea8de10bd4" + name = "golang.org/x/text" + packages = [ + "collate", + "collate/build", + "internal/colltab", + "internal/gen", + "internal/tag", + "internal/triegen", + "internal/ucd", + "language", + "secure/bidirule", + "transform", + "unicode/bidi", + "unicode/cldr", + "unicode/norm", + "unicode/rangetable", + ] + pruneopts = "" + revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0" + version = "v0.3.0" + +[[projects]] + branch = "master" + digest = "1:ee38b21d82650d7a636bc119b87490a32282f14dcc0bbc15d46dda6ccbc2c5bc" + name = "google.golang.org/api" + packages = ["support/bundler"] + pruneopts = "" + revision = "7fb5a8353b60cae0caa99dd43cd047af9ed6476c" + +[[projects]] + branch = "master" + digest = "1:849525811c9f6ae1f5bd9b866adb4c9436f4a12d767f48e33bf343596d4aafd7" + name = "google.golang.org/genproto" + packages = ["googleapis/rpc/status"] + pruneopts = "" + revision = "94acd270e44e65579b9ee3cdab25034d33fed608" + +[[projects]] + digest = "1:15656947b87a6a240e61dcfae9e71a55a8d5677f240d12ab48f02cdbabf1e309" + name = "google.golang.org/grpc" + packages = [ + ".", + "balancer", + "balancer/base", + "balancer/roundrobin", + "codes", + "connectivity", + "credentials", + "encoding", + "encoding/proto", + "grpclog", + "internal", + "internal/backoff", + "internal/channelz", + "internal/envconfig", + "internal/grpcrand", + "internal/transport", + "keepalive", + "metadata", + "naming", + "peer", + "resolver", + "resolver/dns", + "resolver/passthrough", + "stats", + "status", + "tap", + ] + pruneopts = "" + revision = "8dea3dc473e90c8179e519d91302d0597c0ca1d1" + version = "v1.15.0" + [[projects]] branch = "v1" digest = "1:1d01f96bc2293b56c3dec797b8f976d7613fb30ce92bfbc994130404f7f7f031" @@ -75,6 +241,7 @@ "github.com/Azure/go-autorest/autorest/date", "github.com/Azure/go-autorest/autorest/to", "github.com/Azure/go-autorest/autorest/validation", + "github.com/Azure/go-autorest/tracing", "github.com/satori/go.uuid", "github.com/shopspring/decimal", "gopkg.in/check.v1", diff --git a/test/src/tests/Gopkg.toml b/test/src/tests/Gopkg.toml index e31e66134..a946093fd 100644 --- a/test/src/tests/Gopkg.toml +++ b/test/src/tests/Gopkg.toml @@ -22,7 +22,7 @@ [[constraint]] name = "github.com/Azure/go-autorest" - version = "11.1.1" + version = "11.2.0" [[constraint]] name = "github.com/satori/go.uuid" diff --git a/test/src/tests/generated/additional-properties/models.go b/test/src/tests/generated/additional-properties/models.go index 0259b742f..4f3bd2429 100644 --- a/test/src/tests/generated/additional-properties/models.go +++ b/test/src/tests/generated/additional-properties/models.go @@ -11,6 +11,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/additional-properties" + // CatAPTrue ... type CatAPTrue struct { autorest.Response `json:"-"` diff --git a/test/src/tests/generated/additional-properties/pets.go b/test/src/tests/generated/additional-properties/pets.go index 2ce795822..a0de45017 100644 --- a/test/src/tests/generated/additional-properties/pets.go +++ b/test/src/tests/generated/additional-properties/pets.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewPetsClientWithBaseURI(baseURI string) PetsClient { // CreateAPInProperties create a Pet which contains more properties than what is defined. func (client PetsClient) CreateAPInProperties(ctx context.Context, createParameters PetAPInProperties) (result PetAPInProperties, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PetsClient.CreateAPInProperties") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: createParameters, Constraints: []validation.Constraint{{Target: "createParameters.ID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -91,6 +102,16 @@ func (client PetsClient) CreateAPInPropertiesResponder(resp *http.Response) (res // CreateAPInPropertiesWithAPString create a Pet which contains more properties than what is defined. func (client PetsClient) CreateAPInPropertiesWithAPString(ctx context.Context, createParameters PetAPInPropertiesWithAPString) (result PetAPInPropertiesWithAPString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PetsClient.CreateAPInPropertiesWithAPString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: createParameters, Constraints: []validation.Constraint{{Target: "createParameters.ID", Name: validation.Null, Rule: true, Chain: nil}, @@ -152,6 +173,16 @@ func (client PetsClient) CreateAPInPropertiesWithAPStringResponder(resp *http.Re // CreateAPObject create a Pet which contains more properties than what is defined. func (client PetsClient) CreateAPObject(ctx context.Context, createParameters PetAPObject) (result PetAPObject, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PetsClient.CreateAPObject") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: createParameters, Constraints: []validation.Constraint{{Target: "createParameters.ID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -212,6 +243,16 @@ func (client PetsClient) CreateAPObjectResponder(resp *http.Response) (result Pe // CreateAPString create a Pet which contains more properties than what is defined. func (client PetsClient) CreateAPString(ctx context.Context, createParameters PetAPString) (result PetAPString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PetsClient.CreateAPString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: createParameters, Constraints: []validation.Constraint{{Target: "createParameters.ID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -272,6 +313,16 @@ func (client PetsClient) CreateAPStringResponder(resp *http.Response) (result Pe // CreateAPTrue create a Pet which contains more properties than what is defined. func (client PetsClient) CreateAPTrue(ctx context.Context, createParameters PetAPTrue) (result PetAPTrue, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PetsClient.CreateAPTrue") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: createParameters, Constraints: []validation.Constraint{{Target: "createParameters.ID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -332,6 +383,16 @@ func (client PetsClient) CreateAPTrueResponder(resp *http.Response) (result PetA // CreateCatAPTrue create a CatAPTrue which contains more properties than what is defined. func (client PetsClient) CreateCatAPTrue(ctx context.Context, createParameters CatAPTrue) (result CatAPTrue, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PetsClient.CreateCatAPTrue") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.CreateCatAPTruePreparer(ctx, createParameters) if err != nil { err = autorest.NewErrorWithError(err, "additionalproperties.PetsClient", "CreateCatAPTrue", nil, "Failure preparing request") diff --git a/test/src/tests/generated/azurereport/client.go b/test/src/tests/generated/azurereport/client.go index 1558e8a28..a8247ffa5 100644 --- a/test/src/tests/generated/azurereport/client.go +++ b/test/src/tests/generated/azurereport/client.go @@ -13,6 +13,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -45,6 +46,16 @@ func NewWithBaseURI(baseURI string) BaseClient { // qualifier - if specified, qualifies the generated report further (e.g. '2.7' vs '3.5' in for Python). The // only effect is, that generators that run all tests several times, can distinguish the generated reports. func (client BaseClient) GetReport(ctx context.Context, qualifier string) (result SetInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetReport") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetReportPreparer(ctx, qualifier) if err != nil { err = autorest.NewErrorWithError(err, "azurereport.BaseClient", "GetReport", nil, "Failure preparing request") diff --git a/test/src/tests/generated/azurereport/models.go b/test/src/tests/generated/azurereport/models.go index d4486c96f..d7bfd998e 100644 --- a/test/src/tests/generated/azurereport/models.go +++ b/test/src/tests/generated/azurereport/models.go @@ -11,6 +11,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/azurereport" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/body-array/array.go b/test/src/tests/generated/body-array/array.go index 883f3da32..9b3b42c29 100644 --- a/test/src/tests/generated/body-array/array.go +++ b/test/src/tests/generated/body-array/array.go @@ -12,6 +12,7 @@ import ( "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "github.com/satori/go.uuid" "net/http" ) @@ -33,6 +34,16 @@ func NewArrayClientWithBaseURI(baseURI string) ArrayClient { // GetArrayEmpty get an empty array [] func (client ArrayClient) GetArrayEmpty(ctx context.Context) (result ListListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetArrayEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetArrayEmpty", nil, "Failure preparing request") @@ -85,6 +96,16 @@ func (client ArrayClient) GetArrayEmptyResponder(resp *http.Response) (result Li // GetArrayItemEmpty get an array of array of strings [['1', '2', '3'], [], ['7', '8', '9']] func (client ArrayClient) GetArrayItemEmpty(ctx context.Context) (result ListListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetArrayItemEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayItemEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetArrayItemEmpty", nil, "Failure preparing request") @@ -137,6 +158,16 @@ func (client ArrayClient) GetArrayItemEmptyResponder(resp *http.Response) (resul // GetArrayItemNull get an array of array of strings [['1', '2', '3'], null, ['7', '8', '9']] func (client ArrayClient) GetArrayItemNull(ctx context.Context) (result ListListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetArrayItemNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayItemNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetArrayItemNull", nil, "Failure preparing request") @@ -189,6 +220,16 @@ func (client ArrayClient) GetArrayItemNullResponder(resp *http.Response) (result // GetArrayNull get a null array func (client ArrayClient) GetArrayNull(ctx context.Context) (result ListListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetArrayNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetArrayNull", nil, "Failure preparing request") @@ -241,6 +282,16 @@ func (client ArrayClient) GetArrayNullResponder(resp *http.Response) (result Lis // GetArrayValid get an array of array of strings [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']] func (client ArrayClient) GetArrayValid(ctx context.Context) (result ListListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetArrayValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetArrayValid", nil, "Failure preparing request") @@ -294,6 +345,16 @@ func (client ArrayClient) GetArrayValidResponder(resp *http.Response) (result Li // GetBase64URL get array value ['a string that gets encoded with base64url', 'test string' 'Lorem ipsum'] with the // items base64url encoded func (client ArrayClient) GetBase64URL(ctx context.Context) (result ListBase64URL, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetBase64URL") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBase64URLPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetBase64URL", nil, "Failure preparing request") @@ -346,6 +407,16 @@ func (client ArrayClient) GetBase64URLResponder(resp *http.Response) (result Lis // GetBooleanInvalidNull get boolean array value [true, null, false] func (client ArrayClient) GetBooleanInvalidNull(ctx context.Context) (result ListBool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetBooleanInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetBooleanInvalidNull", nil, "Failure preparing request") @@ -398,6 +469,16 @@ func (client ArrayClient) GetBooleanInvalidNullResponder(resp *http.Response) (r // GetBooleanInvalidString get boolean array value [true, 'boolean', false] func (client ArrayClient) GetBooleanInvalidString(ctx context.Context) (result ListBool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetBooleanInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetBooleanInvalidString", nil, "Failure preparing request") @@ -450,6 +531,16 @@ func (client ArrayClient) GetBooleanInvalidStringResponder(resp *http.Response) // GetBooleanTfft get boolean array value [true, false, false, true] func (client ArrayClient) GetBooleanTfft(ctx context.Context) (result ListBool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetBooleanTfft") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanTfftPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetBooleanTfft", nil, "Failure preparing request") @@ -502,6 +593,16 @@ func (client ArrayClient) GetBooleanTfftResponder(resp *http.Response) (result L // GetByteInvalidNull get byte array value [hex(AB, AC, AD), null] with the first item base64 encoded func (client ArrayClient) GetByteInvalidNull(ctx context.Context) (result ListByteArray, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetByteInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetByteInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetByteInvalidNull", nil, "Failure preparing request") @@ -555,6 +656,16 @@ func (client ArrayClient) GetByteInvalidNullResponder(resp *http.Response) (resu // GetByteValid get byte array value [hex(FF FF FF FA), hex(01 02 03), hex (25, 29, 43)] with each item encoded in // base64 func (client ArrayClient) GetByteValid(ctx context.Context) (result ListByteArray, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetByteValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetByteValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetByteValid", nil, "Failure preparing request") @@ -607,6 +718,16 @@ func (client ArrayClient) GetByteValidResponder(resp *http.Response) (result Lis // GetComplexEmpty get empty array of complex type [] func (client ArrayClient) GetComplexEmpty(ctx context.Context) (result ListProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetComplexEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetComplexEmpty", nil, "Failure preparing request") @@ -660,6 +781,16 @@ func (client ArrayClient) GetComplexEmptyResponder(resp *http.Response) (result // GetComplexItemEmpty get array of complex type with empty item [{'integer': 1 'string': '2'}, {}, {'integer': 5, // 'string': '6'}] func (client ArrayClient) GetComplexItemEmpty(ctx context.Context) (result ListProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetComplexItemEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexItemEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetComplexItemEmpty", nil, "Failure preparing request") @@ -713,6 +844,16 @@ func (client ArrayClient) GetComplexItemEmptyResponder(resp *http.Response) (res // GetComplexItemNull get array of complex type with null item [{'integer': 1 'string': '2'}, null, {'integer': 5, // 'string': '6'}] func (client ArrayClient) GetComplexItemNull(ctx context.Context) (result ListProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetComplexItemNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexItemNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetComplexItemNull", nil, "Failure preparing request") @@ -765,6 +906,16 @@ func (client ArrayClient) GetComplexItemNullResponder(resp *http.Response) (resu // GetComplexNull get array of complex type null value func (client ArrayClient) GetComplexNull(ctx context.Context) (result ListProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetComplexNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetComplexNull", nil, "Failure preparing request") @@ -818,6 +969,16 @@ func (client ArrayClient) GetComplexNullResponder(resp *http.Response) (result L // GetComplexValid get array of complex type with [{'integer': 1 'string': '2'}, {'integer': 3, 'string': '4'}, // {'integer': 5, 'string': '6'}] func (client ArrayClient) GetComplexValid(ctx context.Context) (result ListProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetComplexValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetComplexValid", nil, "Failure preparing request") @@ -870,6 +1031,16 @@ func (client ArrayClient) GetComplexValidResponder(resp *http.Response) (result // GetDateInvalidChars get date array value ['2011-03-22', 'date'] func (client ArrayClient) GetDateInvalidChars(ctx context.Context) (result ListDate, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDateInvalidChars") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateInvalidCharsPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDateInvalidChars", nil, "Failure preparing request") @@ -922,6 +1093,16 @@ func (client ArrayClient) GetDateInvalidCharsResponder(resp *http.Response) (res // GetDateInvalidNull get date array value ['2012-01-01', null, '1776-07-04'] func (client ArrayClient) GetDateInvalidNull(ctx context.Context) (result ListDate, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDateInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDateInvalidNull", nil, "Failure preparing request") @@ -974,6 +1155,16 @@ func (client ArrayClient) GetDateInvalidNullResponder(resp *http.Response) (resu // GetDateTimeInvalidChars get date array value ['2000-12-01t00:00:01z', 'date-time'] func (client ArrayClient) GetDateTimeInvalidChars(ctx context.Context) (result ListDateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDateTimeInvalidChars") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeInvalidCharsPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDateTimeInvalidChars", nil, "Failure preparing request") @@ -1026,6 +1217,16 @@ func (client ArrayClient) GetDateTimeInvalidCharsResponder(resp *http.Response) // GetDateTimeInvalidNull get date array value ['2000-12-01t00:00:01z', null] func (client ArrayClient) GetDateTimeInvalidNull(ctx context.Context) (result ListDateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDateTimeInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDateTimeInvalidNull", nil, "Failure preparing request") @@ -1079,6 +1280,16 @@ func (client ArrayClient) GetDateTimeInvalidNullResponder(resp *http.Response) ( // GetDateTimeRfc1123Valid get date-time array value ['Fri, 01 Dec 2000 00:00:01 GMT', 'Wed, 02 Jan 1980 00:11:35 GMT', // 'Wed, 12 Oct 1492 10:15:01 GMT'] func (client ArrayClient) GetDateTimeRfc1123Valid(ctx context.Context) (result ListDateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDateTimeRfc1123Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeRfc1123ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDateTimeRfc1123Valid", nil, "Failure preparing request") @@ -1132,6 +1343,16 @@ func (client ArrayClient) GetDateTimeRfc1123ValidResponder(resp *http.Response) // GetDateTimeValid get date-time array value ['2000-12-01t00:00:01z', '1980-01-02T00:11:35+01:00', // '1492-10-12T10:15:01-08:00'] func (client ArrayClient) GetDateTimeValid(ctx context.Context) (result ListDateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDateTimeValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDateTimeValid", nil, "Failure preparing request") @@ -1184,6 +1405,16 @@ func (client ArrayClient) GetDateTimeValidResponder(resp *http.Response) (result // GetDateValid get integer array value ['2000-12-01', '1980-01-02', '1492-10-12'] func (client ArrayClient) GetDateValid(ctx context.Context) (result ListDate, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDateValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDateValid", nil, "Failure preparing request") @@ -1236,6 +1467,16 @@ func (client ArrayClient) GetDateValidResponder(resp *http.Response) (result Lis // GetDictionaryEmpty get an array of Dictionaries of type with value [] func (client ArrayClient) GetDictionaryEmpty(ctx context.Context) (result ListSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDictionaryEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDictionaryEmpty", nil, "Failure preparing request") @@ -1289,6 +1530,16 @@ func (client ArrayClient) GetDictionaryEmptyResponder(resp *http.Response) (resu // GetDictionaryItemEmpty get an array of Dictionaries of type with value [{'1': 'one', '2': 'two', // '3': 'three'}, {}, {'7': 'seven', '8': 'eight', '9': 'nine'}] func (client ArrayClient) GetDictionaryItemEmpty(ctx context.Context) (result ListSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDictionaryItemEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryItemEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDictionaryItemEmpty", nil, "Failure preparing request") @@ -1342,6 +1593,16 @@ func (client ArrayClient) GetDictionaryItemEmptyResponder(resp *http.Response) ( // GetDictionaryItemNull get an array of Dictionaries of type with value [{'1': 'one', '2': 'two', // '3': 'three'}, null, {'7': 'seven', '8': 'eight', '9': 'nine'}] func (client ArrayClient) GetDictionaryItemNull(ctx context.Context) (result ListSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDictionaryItemNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryItemNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDictionaryItemNull", nil, "Failure preparing request") @@ -1394,6 +1655,16 @@ func (client ArrayClient) GetDictionaryItemNullResponder(resp *http.Response) (r // GetDictionaryNull get an array of Dictionaries with value null func (client ArrayClient) GetDictionaryNull(ctx context.Context) (result ListSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDictionaryNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDictionaryNull", nil, "Failure preparing request") @@ -1447,6 +1718,16 @@ func (client ArrayClient) GetDictionaryNullResponder(resp *http.Response) (resul // GetDictionaryValid get an array of Dictionaries of type with value [{'1': 'one', '2': 'two', '3': // 'three'}, {'4': 'four', '5': 'five', '6': 'six'}, {'7': 'seven', '8': 'eight', '9': 'nine'}] func (client ArrayClient) GetDictionaryValid(ctx context.Context) (result ListSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDictionaryValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDictionaryValid", nil, "Failure preparing request") @@ -1499,6 +1780,16 @@ func (client ArrayClient) GetDictionaryValidResponder(resp *http.Response) (resu // GetDoubleInvalidNull get float array value [0.0, null, -1.2e20] func (client ArrayClient) GetDoubleInvalidNull(ctx context.Context) (result ListFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDoubleInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDoubleInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDoubleInvalidNull", nil, "Failure preparing request") @@ -1551,6 +1842,16 @@ func (client ArrayClient) GetDoubleInvalidNullResponder(resp *http.Response) (re // GetDoubleInvalidString get boolean array value [1.0, 'number', 0.0] func (client ArrayClient) GetDoubleInvalidString(ctx context.Context) (result ListFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDoubleInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDoubleInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDoubleInvalidString", nil, "Failure preparing request") @@ -1603,6 +1904,16 @@ func (client ArrayClient) GetDoubleInvalidStringResponder(resp *http.Response) ( // GetDoubleValid get float array value [0, -0.01, 1.2e20] func (client ArrayClient) GetDoubleValid(ctx context.Context) (result ListFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDoubleValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDoubleValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDoubleValid", nil, "Failure preparing request") @@ -1655,6 +1966,16 @@ func (client ArrayClient) GetDoubleValidResponder(resp *http.Response) (result L // GetDurationValid get duration array value ['P123DT22H14M12.011S', 'P5DT1H0M0S'] func (client ArrayClient) GetDurationValid(ctx context.Context) (result ListTimeSpan, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetDurationValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDurationValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetDurationValid", nil, "Failure preparing request") @@ -1707,6 +2028,16 @@ func (client ArrayClient) GetDurationValidResponder(resp *http.Response) (result // GetEmpty get empty array value [] func (client ArrayClient) GetEmpty(ctx context.Context) (result ListInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetEmpty", nil, "Failure preparing request") @@ -1759,6 +2090,16 @@ func (client ArrayClient) GetEmptyResponder(resp *http.Response) (result ListInt // GetEnumValid get enum array value ['foo1', 'foo2', 'foo3'] func (client ArrayClient) GetEnumValid(ctx context.Context) (result ListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetEnumValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEnumValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetEnumValid", nil, "Failure preparing request") @@ -1811,6 +2152,16 @@ func (client ArrayClient) GetEnumValidResponder(resp *http.Response) (result Lis // GetFloatInvalidNull get float array value [0.0, null, -1.2e20] func (client ArrayClient) GetFloatInvalidNull(ctx context.Context) (result ListFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetFloatInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFloatInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetFloatInvalidNull", nil, "Failure preparing request") @@ -1863,6 +2214,16 @@ func (client ArrayClient) GetFloatInvalidNullResponder(resp *http.Response) (res // GetFloatInvalidString get boolean array value [1.0, 'number', 0.0] func (client ArrayClient) GetFloatInvalidString(ctx context.Context) (result ListFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetFloatInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFloatInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetFloatInvalidString", nil, "Failure preparing request") @@ -1915,6 +2276,16 @@ func (client ArrayClient) GetFloatInvalidStringResponder(resp *http.Response) (r // GetFloatValid get float array value [0, -0.01, 1.2e20] func (client ArrayClient) GetFloatValid(ctx context.Context) (result ListFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetFloatValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFloatValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetFloatValid", nil, "Failure preparing request") @@ -1967,6 +2338,16 @@ func (client ArrayClient) GetFloatValidResponder(resp *http.Response) (result Li // GetIntegerValid get integer array value [1, -1, 3, 300] func (client ArrayClient) GetIntegerValid(ctx context.Context) (result ListInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetIntegerValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntegerValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetIntegerValid", nil, "Failure preparing request") @@ -2019,6 +2400,16 @@ func (client ArrayClient) GetIntegerValidResponder(resp *http.Response) (result // GetIntInvalidNull get integer array value [1, null, 0] func (client ArrayClient) GetIntInvalidNull(ctx context.Context) (result ListInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetIntInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetIntInvalidNull", nil, "Failure preparing request") @@ -2071,6 +2462,16 @@ func (client ArrayClient) GetIntInvalidNullResponder(resp *http.Response) (resul // GetIntInvalidString get integer array value [1, 'integer', 0] func (client ArrayClient) GetIntInvalidString(ctx context.Context) (result ListInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetIntInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetIntInvalidString", nil, "Failure preparing request") @@ -2123,6 +2524,16 @@ func (client ArrayClient) GetIntInvalidStringResponder(resp *http.Response) (res // GetInvalid get invalid array [1, 2, 3 func (client ArrayClient) GetInvalid(ctx context.Context) (result ListInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetInvalid", nil, "Failure preparing request") @@ -2175,6 +2586,16 @@ func (client ArrayClient) GetInvalidResponder(resp *http.Response) (result ListI // GetLongInvalidNull get long array value [1, null, 0] func (client ArrayClient) GetLongInvalidNull(ctx context.Context) (result ListInt64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetLongInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLongInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetLongInvalidNull", nil, "Failure preparing request") @@ -2227,6 +2648,16 @@ func (client ArrayClient) GetLongInvalidNullResponder(resp *http.Response) (resu // GetLongInvalidString get long array value [1, 'integer', 0] func (client ArrayClient) GetLongInvalidString(ctx context.Context) (result ListInt64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetLongInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLongInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetLongInvalidString", nil, "Failure preparing request") @@ -2279,6 +2710,16 @@ func (client ArrayClient) GetLongInvalidStringResponder(resp *http.Response) (re // GetLongValid get integer array value [1, -1, 3, 300] func (client ArrayClient) GetLongValid(ctx context.Context) (result ListInt64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetLongValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLongValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetLongValid", nil, "Failure preparing request") @@ -2331,6 +2772,16 @@ func (client ArrayClient) GetLongValidResponder(resp *http.Response) (result Lis // GetNull get null array value func (client ArrayClient) GetNull(ctx context.Context) (result ListInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetNull", nil, "Failure preparing request") @@ -2383,6 +2834,16 @@ func (client ArrayClient) GetNullResponder(resp *http.Response) (result ListInt3 // GetStringEnumValid get enum array value ['foo1', 'foo2', 'foo3'] func (client ArrayClient) GetStringEnumValid(ctx context.Context) (result ListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetStringEnumValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetStringEnumValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetStringEnumValid", nil, "Failure preparing request") @@ -2435,6 +2896,16 @@ func (client ArrayClient) GetStringEnumValidResponder(resp *http.Response) (resu // GetStringValid get string array value ['foo1', 'foo2', 'foo3'] func (client ArrayClient) GetStringValid(ctx context.Context) (result ListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetStringValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetStringValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetStringValid", nil, "Failure preparing request") @@ -2487,6 +2958,16 @@ func (client ArrayClient) GetStringValidResponder(resp *http.Response) (result L // GetStringWithInvalid get string array value ['foo', 123, 'foo2'] func (client ArrayClient) GetStringWithInvalid(ctx context.Context) (result ListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetStringWithInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetStringWithInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetStringWithInvalid", nil, "Failure preparing request") @@ -2539,6 +3020,16 @@ func (client ArrayClient) GetStringWithInvalidResponder(resp *http.Response) (re // GetStringWithNull get string array value ['foo', null, 'foo2'] func (client ArrayClient) GetStringWithNull(ctx context.Context) (result ListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetStringWithNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetStringWithNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetStringWithNull", nil, "Failure preparing request") @@ -2591,6 +3082,16 @@ func (client ArrayClient) GetStringWithNullResponder(resp *http.Response) (resul // GetUUIDInvalidChars get uuid array value ['6dcc7237-45fe-45c4-8a6b-3a8a3f625652', 'foo'] func (client ArrayClient) GetUUIDInvalidChars(ctx context.Context) (result ListUUID, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetUUIDInvalidChars") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUUIDInvalidCharsPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetUUIDInvalidChars", nil, "Failure preparing request") @@ -2644,6 +3145,16 @@ func (client ArrayClient) GetUUIDInvalidCharsResponder(resp *http.Response) (res // GetUUIDValid get uuid array value ['6dcc7237-45fe-45c4-8a6b-3a8a3f625652', 'd1399005-30f7-40d6-8da6-dd7c89ad34db', // 'f42f6aa1-a5bc-4ddf-907e-5f915de43205'] func (client ArrayClient) GetUUIDValid(ctx context.Context) (result ListUUID, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetUUIDValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUUIDValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "arraygroup.ArrayClient", "GetUUIDValid", nil, "Failure preparing request") @@ -2696,6 +3207,16 @@ func (client ArrayClient) GetUUIDValidResponder(resp *http.Response) (result Lis // PutArrayValid put An array of array of strings [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']] func (client ArrayClient) PutArrayValid(ctx context.Context, arrayBody [][]string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutArrayValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2755,6 +3276,16 @@ func (client ArrayClient) PutArrayValidResponder(resp *http.Response) (result au // PutBooleanTfft set array value empty [true, false, false, true] func (client ArrayClient) PutBooleanTfft(ctx context.Context, arrayBody []bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutBooleanTfft") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2815,6 +3346,16 @@ func (client ArrayClient) PutBooleanTfftResponder(resp *http.Response) (result a // PutByteValid put the array value [hex(FF FF FF FA), hex(01 02 03), hex (25, 29, 43)] with each elementencoded in // base 64 func (client ArrayClient) PutByteValid(ctx context.Context, arrayBody [][]byte) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutByteValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2875,6 +3416,16 @@ func (client ArrayClient) PutByteValidResponder(resp *http.Response) (result aut // PutComplexValid put an array of complex type with values [{'integer': 1 'string': '2'}, {'integer': 3, 'string': // '4'}, {'integer': 5, 'string': '6'}] func (client ArrayClient) PutComplexValid(ctx context.Context, arrayBody []Product) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutComplexValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2935,6 +3486,16 @@ func (client ArrayClient) PutComplexValidResponder(resp *http.Response) (result // PutDateTimeRfc1123Valid set array value ['Fri, 01 Dec 2000 00:00:01 GMT', 'Wed, 02 Jan 1980 00:11:35 GMT', 'Wed, 12 // Oct 1492 10:15:01 GMT'] func (client ArrayClient) PutDateTimeRfc1123Valid(ctx context.Context, arrayBody []date.TimeRFC1123) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutDateTimeRfc1123Valid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2994,6 +3555,16 @@ func (client ArrayClient) PutDateTimeRfc1123ValidResponder(resp *http.Response) // PutDateTimeValid set array value ['2000-12-01t00:00:01z', '1980-01-02T00:11:35+01:00', '1492-10-12T10:15:01-08:00'] func (client ArrayClient) PutDateTimeValid(ctx context.Context, arrayBody []date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutDateTimeValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3053,6 +3624,16 @@ func (client ArrayClient) PutDateTimeValidResponder(resp *http.Response) (result // PutDateValid set array value ['2000-12-01', '1980-01-02', '1492-10-12'] func (client ArrayClient) PutDateValid(ctx context.Context, arrayBody []date.Date) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutDateValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3113,6 +3694,16 @@ func (client ArrayClient) PutDateValidResponder(resp *http.Response) (result aut // PutDictionaryValid get an array of Dictionaries of type with value [{'1': 'one', '2': 'two', '3': // 'three'}, {'4': 'four', '5': 'five', '6': 'six'}, {'7': 'seven', '8': 'eight', '9': 'nine'}] func (client ArrayClient) PutDictionaryValid(ctx context.Context, arrayBody []map[string]*string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutDictionaryValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3172,6 +3763,16 @@ func (client ArrayClient) PutDictionaryValidResponder(resp *http.Response) (resu // PutDoubleValid set array value [0, -0.01, 1.2e20] func (client ArrayClient) PutDoubleValid(ctx context.Context, arrayBody []float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutDoubleValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3231,6 +3832,16 @@ func (client ArrayClient) PutDoubleValidResponder(resp *http.Response) (result a // PutDurationValid set array value ['P123DT22H14M12.011S', 'P5DT1H0M0S'] func (client ArrayClient) PutDurationValid(ctx context.Context, arrayBody []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutDurationValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3290,6 +3901,16 @@ func (client ArrayClient) PutDurationValidResponder(resp *http.Response) (result // PutEmpty set array value empty [] func (client ArrayClient) PutEmpty(ctx context.Context, arrayBody []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3349,6 +3970,16 @@ func (client ArrayClient) PutEmptyResponder(resp *http.Response) (result autores // PutEnumValid set array value ['foo1', 'foo2', 'foo3'] func (client ArrayClient) PutEnumValid(ctx context.Context, arrayBody []FooEnum) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutEnumValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3408,6 +4039,16 @@ func (client ArrayClient) PutEnumValidResponder(resp *http.Response) (result aut // PutFloatValid set array value [0, -0.01, 1.2e20] func (client ArrayClient) PutFloatValid(ctx context.Context, arrayBody []float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutFloatValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3467,6 +4108,16 @@ func (client ArrayClient) PutFloatValidResponder(resp *http.Response) (result au // PutIntegerValid set array value empty [1, -1, 3, 300] func (client ArrayClient) PutIntegerValid(ctx context.Context, arrayBody []int32) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutIntegerValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3526,6 +4177,16 @@ func (client ArrayClient) PutIntegerValidResponder(resp *http.Response) (result // PutLongValid set array value empty [1, -1, 3, 300] func (client ArrayClient) PutLongValid(ctx context.Context, arrayBody []int64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutLongValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3585,6 +4246,16 @@ func (client ArrayClient) PutLongValidResponder(resp *http.Response) (result aut // PutStringEnumValid set array value ['foo1', 'foo2', 'foo3'] func (client ArrayClient) PutStringEnumValid(ctx context.Context, arrayBody []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutStringEnumValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3644,6 +4315,16 @@ func (client ArrayClient) PutStringEnumValidResponder(resp *http.Response) (resu // PutStringValid set array value ['foo1', 'foo2', 'foo3'] func (client ArrayClient) PutStringValid(ctx context.Context, arrayBody []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutStringValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3704,6 +4385,16 @@ func (client ArrayClient) PutStringValidResponder(resp *http.Response) (result a // PutUUIDValid set array value ['6dcc7237-45fe-45c4-8a6b-3a8a3f625652', 'd1399005-30f7-40d6-8da6-dd7c89ad34db', // 'f42f6aa1-a5bc-4ddf-907e-5f915de43205'] func (client ArrayClient) PutUUIDValid(ctx context.Context, arrayBody []uuid.UUID) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutUUIDValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { diff --git a/test/src/tests/generated/body-array/models.go b/test/src/tests/generated/body-array/models.go index 4f79e8d96..2c8c52ff7 100644 --- a/test/src/tests/generated/body-array/models.go +++ b/test/src/tests/generated/body-array/models.go @@ -12,6 +12,9 @@ import ( "github.com/satori/go.uuid" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-array" + // FooEnum enumerates the values for foo enum. type FooEnum string diff --git a/test/src/tests/generated/body-boolean/bool.go b/test/src/tests/generated/body-boolean/bool.go index 7cd47e57a..f4fb4f6e6 100644 --- a/test/src/tests/generated/body-boolean/bool.go +++ b/test/src/tests/generated/body-boolean/bool.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewBoolClientWithBaseURI(baseURI string) BoolClient { // GetFalse get false Boolean value func (client BoolClient) GetFalse(ctx context.Context) (result BoolModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BoolClient.GetFalse") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFalsePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "booleangroup.BoolClient", "GetFalse", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client BoolClient) GetFalseResponder(resp *http.Response) (result BoolMode // GetInvalid get invalid Boolean value func (client BoolClient) GetInvalid(ctx context.Context) (result BoolModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BoolClient.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "booleangroup.BoolClient", "GetInvalid", nil, "Failure preparing request") @@ -134,6 +155,16 @@ func (client BoolClient) GetInvalidResponder(resp *http.Response) (result BoolMo // GetNull get null Boolean value func (client BoolClient) GetNull(ctx context.Context) (result BoolModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BoolClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "booleangroup.BoolClient", "GetNull", nil, "Failure preparing request") @@ -186,6 +217,16 @@ func (client BoolClient) GetNullResponder(resp *http.Response) (result BoolModel // GetTrue get true Boolean value func (client BoolClient) GetTrue(ctx context.Context) (result BoolModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BoolClient.GetTrue") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetTruePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "booleangroup.BoolClient", "GetTrue", nil, "Failure preparing request") @@ -238,6 +279,16 @@ func (client BoolClient) GetTrueResponder(resp *http.Response) (result BoolModel // PutFalse set Boolean value false func (client BoolClient) PutFalse(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BoolClient.PutFalse") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutFalsePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "booleangroup.BoolClient", "PutFalse", nil, "Failure preparing request") @@ -291,6 +342,16 @@ func (client BoolClient) PutFalseResponder(resp *http.Response) (result autorest // PutTrue set Boolean value true func (client BoolClient) PutTrue(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BoolClient.PutTrue") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutTruePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "booleangroup.BoolClient", "PutTrue", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-boolean/models.go b/test/src/tests/generated/body-boolean/models.go index 26cf18a75..c80cddb42 100644 --- a/test/src/tests/generated/body-boolean/models.go +++ b/test/src/tests/generated/body-boolean/models.go @@ -10,6 +10,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-boolean" + // BoolModel ... type BoolModel struct { autorest.Response `json:"-"` diff --git a/test/src/tests/generated/body-byte/byte.go b/test/src/tests/generated/body-byte/byte.go index a01845f83..7f40a3e2a 100644 --- a/test/src/tests/generated/body-byte/byte.go +++ b/test/src/tests/generated/body-byte/byte.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewByteClientWithBaseURI(baseURI string) ByteClient { // GetEmpty get empty byte value '' func (client ByteClient) GetEmpty(ctx context.Context) (result ByteArray, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ByteClient.GetEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "bytegroup.ByteClient", "GetEmpty", nil, "Failure preparing request") @@ -83,6 +94,16 @@ func (client ByteClient) GetEmptyResponder(resp *http.Response) (result ByteArra // GetInvalid get invalid byte value ':::SWAGGER::::' func (client ByteClient) GetInvalid(ctx context.Context) (result ByteArray, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ByteClient.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "bytegroup.ByteClient", "GetInvalid", nil, "Failure preparing request") @@ -135,6 +156,16 @@ func (client ByteClient) GetInvalidResponder(resp *http.Response) (result ByteAr // GetNonASCII get non-ascii byte string hex(FF FE FD FC FB FA F9 F8 F7 F6) func (client ByteClient) GetNonASCII(ctx context.Context) (result ByteArray, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ByteClient.GetNonASCII") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNonASCIIPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "bytegroup.ByteClient", "GetNonASCII", nil, "Failure preparing request") @@ -187,6 +218,16 @@ func (client ByteClient) GetNonASCIIResponder(resp *http.Response) (result ByteA // GetNull get null byte value func (client ByteClient) GetNull(ctx context.Context) (result ByteArray, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ByteClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "bytegroup.ByteClient", "GetNull", nil, "Failure preparing request") @@ -241,6 +282,16 @@ func (client ByteClient) GetNullResponder(resp *http.Response) (result ByteArray // Parameters: // byteBody - base64-encoded non-ascii byte string hex(FF FE FD FC FB FA F9 F8 F7 F6) func (client ByteClient) PutNonASCII(ctx context.Context, byteBody []byte) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ByteClient.PutNonASCII") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: byteBody, Constraints: []validation.Constraint{{Target: "byteBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { diff --git a/test/src/tests/generated/body-byte/models.go b/test/src/tests/generated/body-byte/models.go index fc1229b4d..db40c682d 100644 --- a/test/src/tests/generated/body-byte/models.go +++ b/test/src/tests/generated/body-byte/models.go @@ -10,6 +10,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-byte" + // ByteArray ... type ByteArray struct { autorest.Response `json:"-"` diff --git a/test/src/tests/generated/body-complex/array.go b/test/src/tests/generated/body-complex/array.go index bdb588fbc..965fd9b2b 100644 --- a/test/src/tests/generated/body-complex/array.go +++ b/test/src/tests/generated/body-complex/array.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewArrayClientWithBaseURI(baseURI string) ArrayClient { // GetEmpty get complex types with array property which is empty func (client ArrayClient) GetEmpty(ctx context.Context) (result ArrayWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.ArrayClient", "GetEmpty", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client ArrayClient) GetEmptyResponder(resp *http.Response) (result ArrayWr // GetNotProvided get complex types with array property while server doesn't provide a response payload func (client ArrayClient) GetNotProvided(ctx context.Context) (result ArrayWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetNotProvided") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNotProvidedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.ArrayClient", "GetNotProvided", nil, "Failure preparing request") @@ -134,6 +155,16 @@ func (client ArrayClient) GetNotProvidedResponder(resp *http.Response) (result A // GetValid get complex types with array property func (client ArrayClient) GetValid(ctx context.Context) (result ArrayWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.GetValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.ArrayClient", "GetValid", nil, "Failure preparing request") @@ -188,6 +219,16 @@ func (client ArrayClient) GetValidResponder(resp *http.Response) (result ArrayWr // Parameters: // complexBody - please put an empty array func (client ArrayClient) PutEmpty(ctx context.Context, complexBody ArrayWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutEmptyPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.ArrayClient", "PutEmpty", nil, "Failure preparing request") @@ -244,6 +285,16 @@ func (client ArrayClient) PutEmptyResponder(resp *http.Response) (result autores // complexBody - please put an array with 4 items: "1, 2, 3, 4", "", null, "&S#$(*Y", "The quick brown fox // jumps over the lazy dog" func (client ArrayClient) PutValid(ctx context.Context, complexBody ArrayWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ArrayClient.PutValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutValidPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.ArrayClient", "PutValid", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-complex/basic.go b/test/src/tests/generated/body-complex/basic.go index bd992ee24..73dc5a416 100644 --- a/test/src/tests/generated/body-complex/basic.go +++ b/test/src/tests/generated/body-complex/basic.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewBasicClientWithBaseURI(baseURI string) BasicClient { // GetEmpty get a basic complex type that is empty func (client BasicClient) GetEmpty(ctx context.Context) (result Basic, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BasicClient.GetEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.BasicClient", "GetEmpty", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client BasicClient) GetEmptyResponder(resp *http.Response) (result Basic, // GetInvalid get a basic complex type that is invalid for the local strong type func (client BasicClient) GetInvalid(ctx context.Context) (result Basic, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BasicClient.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.BasicClient", "GetInvalid", nil, "Failure preparing request") @@ -134,6 +155,16 @@ func (client BasicClient) GetInvalidResponder(resp *http.Response) (result Basic // GetNotProvided get a basic complex type while the server doesn't provide a response payload func (client BasicClient) GetNotProvided(ctx context.Context) (result Basic, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BasicClient.GetNotProvided") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNotProvidedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.BasicClient", "GetNotProvided", nil, "Failure preparing request") @@ -186,6 +217,16 @@ func (client BasicClient) GetNotProvidedResponder(resp *http.Response) (result B // GetNull get a basic complex type whose properties are null func (client BasicClient) GetNull(ctx context.Context) (result Basic, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BasicClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.BasicClient", "GetNull", nil, "Failure preparing request") @@ -238,6 +279,16 @@ func (client BasicClient) GetNullResponder(resp *http.Response) (result Basic, e // GetValid get complex type {id: 2, name: 'abc', color: 'YELLOW'} func (client BasicClient) GetValid(ctx context.Context) (result Basic, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BasicClient.GetValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.BasicClient", "GetValid", nil, "Failure preparing request") @@ -292,6 +343,16 @@ func (client BasicClient) GetValidResponder(resp *http.Response) (result Basic, // Parameters: // complexBody - please put {id: 2, name: 'abc', color: 'Magenta'} func (client BasicClient) PutValid(ctx context.Context, complexBody Basic) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BasicClient.PutValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutValidPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.BasicClient", "PutValid", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-complex/dictionary.go b/test/src/tests/generated/body-complex/dictionary.go index 9d17aaf76..213539d8d 100644 --- a/test/src/tests/generated/body-complex/dictionary.go +++ b/test/src/tests/generated/body-complex/dictionary.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewDictionaryClientWithBaseURI(baseURI string) DictionaryClient { // GetEmpty get complex types with dictionary property which is empty func (client DictionaryClient) GetEmpty(ctx context.Context) (result DictionaryWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.DictionaryClient", "GetEmpty", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client DictionaryClient) GetEmptyResponder(resp *http.Response) (result Di // GetNotProvided get complex types with dictionary property while server doesn't provide a response payload func (client DictionaryClient) GetNotProvided(ctx context.Context) (result DictionaryWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetNotProvided") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNotProvidedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.DictionaryClient", "GetNotProvided", nil, "Failure preparing request") @@ -134,6 +155,16 @@ func (client DictionaryClient) GetNotProvidedResponder(resp *http.Response) (res // GetNull get complex types with dictionary property which is null func (client DictionaryClient) GetNull(ctx context.Context) (result DictionaryWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.DictionaryClient", "GetNull", nil, "Failure preparing request") @@ -186,6 +217,16 @@ func (client DictionaryClient) GetNullResponder(resp *http.Response) (result Dic // GetValid get complex types with dictionary property func (client DictionaryClient) GetValid(ctx context.Context) (result DictionaryWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.DictionaryClient", "GetValid", nil, "Failure preparing request") @@ -240,6 +281,16 @@ func (client DictionaryClient) GetValidResponder(resp *http.Response) (result Di // Parameters: // complexBody - please put an empty dictionary func (client DictionaryClient) PutEmpty(ctx context.Context, complexBody DictionaryWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutEmptyPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.DictionaryClient", "PutEmpty", nil, "Failure preparing request") @@ -296,6 +347,16 @@ func (client DictionaryClient) PutEmptyResponder(resp *http.Response) (result au // complexBody - please put a dictionary with 5 key-value pairs: "txt":"notepad", "bmp":"mspaint", // "xls":"excel", "exe":"", "":null func (client DictionaryClient) PutValid(ctx context.Context, complexBody DictionaryWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutValidPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.DictionaryClient", "PutValid", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-complex/flattencomplex.go b/test/src/tests/generated/body-complex/flattencomplex.go index 1952274de..d17a2a7dc 100644 --- a/test/src/tests/generated/body-complex/flattencomplex.go +++ b/test/src/tests/generated/body-complex/flattencomplex.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewFlattencomplexClientWithBaseURI(baseURI string) FlattencomplexClient { // GetValid sends the get valid request. func (client FlattencomplexClient) GetValid(ctx context.Context) (result MyBaseTypeModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/FlattencomplexClient.GetValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.FlattencomplexClient", "GetValid", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-complex/inheritance.go b/test/src/tests/generated/body-complex/inheritance.go index 2be75a353..d07849892 100644 --- a/test/src/tests/generated/body-complex/inheritance.go +++ b/test/src/tests/generated/body-complex/inheritance.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewInheritanceClientWithBaseURI(baseURI string) InheritanceClient { // GetValid get complex types that extend others func (client InheritanceClient) GetValid(ctx context.Context) (result Siamese, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/InheritanceClient.GetValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.InheritanceClient", "GetValid", nil, "Failure preparing request") @@ -86,6 +97,16 @@ func (client InheritanceClient) GetValidResponder(resp *http.Response) (result S // dogs, the 1st one named "Potato" with id=1 and food="tomato", and the 2nd one named "Tomato" with id=-1 and // food="french fries". func (client InheritanceClient) PutValid(ctx context.Context, complexBody Siamese) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/InheritanceClient.PutValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutValidPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.InheritanceClient", "PutValid", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-complex/models.go b/test/src/tests/generated/body-complex/models.go index 9c04e32db..0b733da16 100644 --- a/test/src/tests/generated/body-complex/models.go +++ b/test/src/tests/generated/body-complex/models.go @@ -12,6 +12,9 @@ import ( "github.com/Azure/go-autorest/autorest/date" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-complex" + // CMYKColors enumerates the values for cmyk colors. type CMYKColors string diff --git a/test/src/tests/generated/body-complex/polymorphicrecursive.go b/test/src/tests/generated/body-complex/polymorphicrecursive.go index 1b42573c7..356c76974 100644 --- a/test/src/tests/generated/body-complex/polymorphicrecursive.go +++ b/test/src/tests/generated/body-complex/polymorphicrecursive.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewPolymorphicrecursiveClientWithBaseURI(baseURI string) Polymorphicrecursi // GetValid get complex types that are polymorphic and have recursive references func (client PolymorphicrecursiveClient) GetValid(ctx context.Context) (result FishModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PolymorphicrecursiveClient.GetValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PolymorphicrecursiveClient", "GetValid", nil, "Failure preparing request") @@ -137,6 +148,16 @@ func (client PolymorphicrecursiveClient) GetValidResponder(resp *http.Response) // ] // } func (client PolymorphicrecursiveClient) PutValid(ctx context.Context, complexBody BasicFish) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PolymorphicrecursiveClient.PutValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: complexBody, Constraints: []validation.Constraint{{Target: "complexBody.Length", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { diff --git a/test/src/tests/generated/body-complex/polymorphism.go b/test/src/tests/generated/body-complex/polymorphism.go index bb412ad8a..ba7b2b0da 100644 --- a/test/src/tests/generated/body-complex/polymorphism.go +++ b/test/src/tests/generated/body-complex/polymorphism.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -32,6 +33,16 @@ func NewPolymorphismClientWithBaseURI(baseURI string) PolymorphismClient { // GetComplicated get complex types that are polymorphic, but not at the root of the hierarchy; also have additional // properties func (client PolymorphismClient) GetComplicated(ctx context.Context) (result SalmonModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PolymorphismClient.GetComplicated") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplicatedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PolymorphismClient", "GetComplicated", nil, "Failure preparing request") @@ -84,6 +95,16 @@ func (client PolymorphismClient) GetComplicatedResponder(resp *http.Response) (r // GetValid get complex types that are polymorphic func (client PolymorphismClient) GetValid(ctx context.Context) (result FishModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PolymorphismClient.GetValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PolymorphismClient", "GetValid", nil, "Failure preparing request") @@ -137,6 +158,16 @@ func (client PolymorphismClient) GetValidResponder(resp *http.Response) (result // PutComplicated put complex types that are polymorphic, but not at the root of the hierarchy; also have additional // properties func (client PolymorphismClient) PutComplicated(ctx context.Context, complexBody BasicSalmon) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PolymorphismClient.PutComplicated") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutComplicatedPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PolymorphismClient", "PutComplicated", nil, "Failure preparing request") @@ -190,6 +221,16 @@ func (client PolymorphismClient) PutComplicatedResponder(resp *http.Response) (r // PutMissingDiscriminator put complex types that are polymorphic, omitting the discriminator func (client PolymorphismClient) PutMissingDiscriminator(ctx context.Context, complexBody BasicSalmon) (result SalmonModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PolymorphismClient.PutMissingDiscriminator") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutMissingDiscriminatorPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PolymorphismClient", "PutMissingDiscriminator", nil, "Failure preparing request") @@ -278,6 +319,16 @@ func (client PolymorphismClient) PutMissingDiscriminatorResponder(resp *http.Res // ] // }; func (client PolymorphismClient) PutValid(ctx context.Context, complexBody BasicFish) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PolymorphismClient.PutValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: complexBody, Constraints: []validation.Constraint{{Target: "complexBody.Length", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -366,6 +417,16 @@ func (client PolymorphismClient) PutValidResponder(resp *http.Response) (result // ] // } func (client PolymorphismClient) PutValidMissingRequired(ctx context.Context, complexBody BasicFish) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PolymorphismClient.PutValidMissingRequired") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: complexBody, Constraints: []validation.Constraint{{Target: "complexBody.Length", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { diff --git a/test/src/tests/generated/body-complex/primitive.go b/test/src/tests/generated/body-complex/primitive.go index 2d94d3d3c..5b1882ee8 100644 --- a/test/src/tests/generated/body-complex/primitive.go +++ b/test/src/tests/generated/body-complex/primitive.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewPrimitiveClientWithBaseURI(baseURI string) PrimitiveClient { // GetBool get complex types with bool properties func (client PrimitiveClient) GetBool(ctx context.Context) (result BooleanWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetBool") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBoolPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetBool", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client PrimitiveClient) GetBoolResponder(resp *http.Response) (result Bool // GetByte get complex types with byte properties func (client PrimitiveClient) GetByte(ctx context.Context) (result ByteWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetByte") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBytePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetByte", nil, "Failure preparing request") @@ -134,6 +155,16 @@ func (client PrimitiveClient) GetByteResponder(resp *http.Response) (result Byte // GetDate get complex types with date properties func (client PrimitiveClient) GetDate(ctx context.Context) (result DateWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetDate") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDatePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetDate", nil, "Failure preparing request") @@ -186,6 +217,16 @@ func (client PrimitiveClient) GetDateResponder(resp *http.Response) (result Date // GetDateTime get complex types with datetime properties func (client PrimitiveClient) GetDateTime(ctx context.Context) (result DatetimeWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetDateTime", nil, "Failure preparing request") @@ -238,6 +279,16 @@ func (client PrimitiveClient) GetDateTimeResponder(resp *http.Response) (result // GetDateTimeRfc1123 get complex types with datetimeRfc1123 properties func (client PrimitiveClient) GetDateTimeRfc1123(ctx context.Context) (result Datetimerfc1123Wrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetDateTimeRfc1123") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeRfc1123Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetDateTimeRfc1123", nil, "Failure preparing request") @@ -290,6 +341,16 @@ func (client PrimitiveClient) GetDateTimeRfc1123Responder(resp *http.Response) ( // GetDouble get complex types with double properties func (client PrimitiveClient) GetDouble(ctx context.Context) (result DoubleWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetDouble") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDoublePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetDouble", nil, "Failure preparing request") @@ -342,6 +403,16 @@ func (client PrimitiveClient) GetDoubleResponder(resp *http.Response) (result Do // GetDuration get complex types with duration properties func (client PrimitiveClient) GetDuration(ctx context.Context) (result DurationWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetDuration") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDurationPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetDuration", nil, "Failure preparing request") @@ -394,6 +465,16 @@ func (client PrimitiveClient) GetDurationResponder(resp *http.Response) (result // GetFloat get complex types with float properties func (client PrimitiveClient) GetFloat(ctx context.Context) (result FloatWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetFloat") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFloatPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetFloat", nil, "Failure preparing request") @@ -446,6 +527,16 @@ func (client PrimitiveClient) GetFloatResponder(resp *http.Response) (result Flo // GetInt get complex types with integer properties func (client PrimitiveClient) GetInt(ctx context.Context) (result IntWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetInt") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetInt", nil, "Failure preparing request") @@ -498,6 +589,16 @@ func (client PrimitiveClient) GetIntResponder(resp *http.Response) (result IntWr // GetLong get complex types with long properties func (client PrimitiveClient) GetLong(ctx context.Context) (result LongWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetLong") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLongPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetLong", nil, "Failure preparing request") @@ -550,6 +651,16 @@ func (client PrimitiveClient) GetLongResponder(resp *http.Response) (result Long // GetString get complex types with string properties func (client PrimitiveClient) GetString(ctx context.Context) (result StringWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.GetString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "GetString", nil, "Failure preparing request") @@ -604,6 +715,16 @@ func (client PrimitiveClient) GetStringResponder(resp *http.Response) (result St // Parameters: // complexBody - please put true and false func (client PrimitiveClient) PutBool(ctx context.Context, complexBody BooleanWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutBool") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBoolPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutBool", nil, "Failure preparing request") @@ -659,6 +780,16 @@ func (client PrimitiveClient) PutBoolResponder(resp *http.Response) (result auto // Parameters: // complexBody - please put non-ascii byte string hex(FF FE FD FC 00 FA F9 F8 F7 F6) func (client PrimitiveClient) PutByte(ctx context.Context, complexBody ByteWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutByte") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBytePreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutByte", nil, "Failure preparing request") @@ -714,6 +845,16 @@ func (client PrimitiveClient) PutByteResponder(resp *http.Response) (result auto // Parameters: // complexBody - please put '0001-01-01' and '2016-02-29' func (client PrimitiveClient) PutDate(ctx context.Context, complexBody DateWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutDate") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutDatePreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutDate", nil, "Failure preparing request") @@ -769,6 +910,16 @@ func (client PrimitiveClient) PutDateResponder(resp *http.Response) (result auto // Parameters: // complexBody - please put '0001-01-01T12:00:00-04:00' and '2015-05-18T11:38:00-08:00' func (client PrimitiveClient) PutDateTime(ctx context.Context, complexBody DatetimeWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutDateTimePreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutDateTime", nil, "Failure preparing request") @@ -824,6 +975,16 @@ func (client PrimitiveClient) PutDateTimeResponder(resp *http.Response) (result // Parameters: // complexBody - please put 'Mon, 01 Jan 0001 12:00:00 GMT' and 'Mon, 18 May 2015 11:38:00 GMT' func (client PrimitiveClient) PutDateTimeRfc1123(ctx context.Context, complexBody Datetimerfc1123Wrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutDateTimeRfc1123") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutDateTimeRfc1123Preparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutDateTimeRfc1123", nil, "Failure preparing request") @@ -879,6 +1040,16 @@ func (client PrimitiveClient) PutDateTimeRfc1123Responder(resp *http.Response) ( // Parameters: // complexBody - please put 3e-100 and -0.000000000000000000000000000000000000000000000000000000005 func (client PrimitiveClient) PutDouble(ctx context.Context, complexBody DoubleWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutDouble") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutDoublePreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutDouble", nil, "Failure preparing request") @@ -934,6 +1105,16 @@ func (client PrimitiveClient) PutDoubleResponder(resp *http.Response) (result au // Parameters: // complexBody - please put 'P123DT22H14M12.011S' func (client PrimitiveClient) PutDuration(ctx context.Context, complexBody DurationWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutDuration") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutDurationPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutDuration", nil, "Failure preparing request") @@ -989,6 +1170,16 @@ func (client PrimitiveClient) PutDurationResponder(resp *http.Response) (result // Parameters: // complexBody - please put 1.05 and -0.003 func (client PrimitiveClient) PutFloat(ctx context.Context, complexBody FloatWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutFloat") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutFloatPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutFloat", nil, "Failure preparing request") @@ -1044,6 +1235,16 @@ func (client PrimitiveClient) PutFloatResponder(resp *http.Response) (result aut // Parameters: // complexBody - please put -1 and 2 func (client PrimitiveClient) PutInt(ctx context.Context, complexBody IntWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutInt") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutIntPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutInt", nil, "Failure preparing request") @@ -1099,6 +1300,16 @@ func (client PrimitiveClient) PutIntResponder(resp *http.Response) (result autor // Parameters: // complexBody - please put 1099511627775 and -999511627788 func (client PrimitiveClient) PutLong(ctx context.Context, complexBody LongWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutLong") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutLongPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutLong", nil, "Failure preparing request") @@ -1154,6 +1365,16 @@ func (client PrimitiveClient) PutLongResponder(resp *http.Response) (result auto // Parameters: // complexBody - please put 'goodrequest', '', and null func (client PrimitiveClient) PutString(ctx context.Context, complexBody StringWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrimitiveClient.PutString") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutStringPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.PrimitiveClient", "PutString", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-complex/readonlyproperty.go b/test/src/tests/generated/body-complex/readonlyproperty.go index 52537eda7..6cf443cce 100644 --- a/test/src/tests/generated/body-complex/readonlyproperty.go +++ b/test/src/tests/generated/body-complex/readonlyproperty.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewReadonlypropertyClientWithBaseURI(baseURI string) ReadonlypropertyClient // GetValid get complex types that have readonly properties func (client ReadonlypropertyClient) GetValid(ctx context.Context) (result ReadonlyObj, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ReadonlypropertyClient.GetValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.ReadonlypropertyClient", "GetValid", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client ReadonlypropertyClient) GetValidResponder(resp *http.Response) (res // PutValid put complex types that have readonly properties func (client ReadonlypropertyClient) PutValid(ctx context.Context, complexBody ReadonlyObj) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ReadonlypropertyClient.PutValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutValidPreparer(ctx, complexBody) if err != nil { err = autorest.NewErrorWithError(err, "complexgroup.ReadonlypropertyClient", "PutValid", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-date/date.go b/test/src/tests/generated/body-date/date.go index cbaec0b1b..534527537 100644 --- a/test/src/tests/generated/body-date/date.go +++ b/test/src/tests/generated/body-date/date.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewDateClientWithBaseURI(baseURI string) DateClient { // GetInvalidDate get invalid date value func (client DateClient) GetInvalidDate(ctx context.Context) (result DateModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DateClient.GetInvalidDate") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidDatePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dategroup.DateClient", "GetInvalidDate", nil, "Failure preparing request") @@ -83,6 +94,16 @@ func (client DateClient) GetInvalidDateResponder(resp *http.Response) (result Da // GetMaxDate get max date value 9999-12-31 func (client DateClient) GetMaxDate(ctx context.Context) (result DateModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DateClient.GetMaxDate") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetMaxDatePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dategroup.DateClient", "GetMaxDate", nil, "Failure preparing request") @@ -135,6 +156,16 @@ func (client DateClient) GetMaxDateResponder(resp *http.Response) (result DateMo // GetMinDate get min date value 0000-01-01 func (client DateClient) GetMinDate(ctx context.Context) (result DateModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DateClient.GetMinDate") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetMinDatePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dategroup.DateClient", "GetMinDate", nil, "Failure preparing request") @@ -187,6 +218,16 @@ func (client DateClient) GetMinDateResponder(resp *http.Response) (result DateMo // GetNull get null date value func (client DateClient) GetNull(ctx context.Context) (result DateModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DateClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dategroup.DateClient", "GetNull", nil, "Failure preparing request") @@ -239,6 +280,16 @@ func (client DateClient) GetNullResponder(resp *http.Response) (result DateModel // GetOverflowDate get overflow date value func (client DateClient) GetOverflowDate(ctx context.Context) (result DateModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DateClient.GetOverflowDate") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetOverflowDatePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dategroup.DateClient", "GetOverflowDate", nil, "Failure preparing request") @@ -291,6 +342,16 @@ func (client DateClient) GetOverflowDateResponder(resp *http.Response) (result D // GetUnderflowDate get underflow date value func (client DateClient) GetUnderflowDate(ctx context.Context) (result DateModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DateClient.GetUnderflowDate") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUnderflowDatePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dategroup.DateClient", "GetUnderflowDate", nil, "Failure preparing request") @@ -343,6 +404,16 @@ func (client DateClient) GetUnderflowDateResponder(resp *http.Response) (result // PutMaxDate put max date value 9999-12-31 func (client DateClient) PutMaxDate(ctx context.Context, dateBody date.Date) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DateClient.PutMaxDate") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutMaxDatePreparer(ctx, dateBody) if err != nil { err = autorest.NewErrorWithError(err, "dategroup.DateClient", "PutMaxDate", nil, "Failure preparing request") @@ -396,6 +467,16 @@ func (client DateClient) PutMaxDateResponder(resp *http.Response) (result autore // PutMinDate put min date value 0000-01-01 func (client DateClient) PutMinDate(ctx context.Context, dateBody date.Date) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DateClient.PutMinDate") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutMinDatePreparer(ctx, dateBody) if err != nil { err = autorest.NewErrorWithError(err, "dategroup.DateClient", "PutMinDate", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-date/models.go b/test/src/tests/generated/body-date/models.go index f943bcce6..a71791a97 100644 --- a/test/src/tests/generated/body-date/models.go +++ b/test/src/tests/generated/body-date/models.go @@ -11,6 +11,9 @@ import ( "github.com/Azure/go-autorest/autorest/date" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-date" + // DateModel ... type DateModel struct { autorest.Response `json:"-"` diff --git a/test/src/tests/generated/body-datetime-rfc1123/datetimerfc1123.go b/test/src/tests/generated/body-datetime-rfc1123/datetimerfc1123.go index 7f51453bc..916f13e9e 100644 --- a/test/src/tests/generated/body-datetime-rfc1123/datetimerfc1123.go +++ b/test/src/tests/generated/body-datetime-rfc1123/datetimerfc1123.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewDatetimerfc1123ClientWithBaseURI(baseURI string) Datetimerfc1123Client { // GetInvalid get invalid datetime value func (client Datetimerfc1123Client) GetInvalid(ctx context.Context) (result DateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "GetInvalid", nil, "Failure preparing request") @@ -83,6 +94,16 @@ func (client Datetimerfc1123Client) GetInvalidResponder(resp *http.Response) (re // GetNull get null datetime value func (client Datetimerfc1123Client) GetNull(ctx context.Context) (result DateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "GetNull", nil, "Failure preparing request") @@ -135,6 +156,16 @@ func (client Datetimerfc1123Client) GetNullResponder(resp *http.Response) (resul // GetOverflow get overflow datetime value func (client Datetimerfc1123Client) GetOverflow(ctx context.Context) (result DateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.GetOverflow") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetOverflowPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "GetOverflow", nil, "Failure preparing request") @@ -187,6 +218,16 @@ func (client Datetimerfc1123Client) GetOverflowResponder(resp *http.Response) (r // GetUnderflow get underflow datetime value func (client Datetimerfc1123Client) GetUnderflow(ctx context.Context) (result DateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.GetUnderflow") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUnderflowPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "GetUnderflow", nil, "Failure preparing request") @@ -239,6 +280,16 @@ func (client Datetimerfc1123Client) GetUnderflowResponder(resp *http.Response) ( // GetUtcLowercaseMaxDateTime get max datetime value fri, 31 dec 9999 23:59:59 gmt func (client Datetimerfc1123Client) GetUtcLowercaseMaxDateTime(ctx context.Context) (result DateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.GetUtcLowercaseMaxDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUtcLowercaseMaxDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "GetUtcLowercaseMaxDateTime", nil, "Failure preparing request") @@ -291,6 +342,16 @@ func (client Datetimerfc1123Client) GetUtcLowercaseMaxDateTimeResponder(resp *ht // GetUtcMinDateTime get min datetime value Mon, 1 Jan 0001 00:00:00 GMT func (client Datetimerfc1123Client) GetUtcMinDateTime(ctx context.Context) (result DateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.GetUtcMinDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUtcMinDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "GetUtcMinDateTime", nil, "Failure preparing request") @@ -343,6 +404,16 @@ func (client Datetimerfc1123Client) GetUtcMinDateTimeResponder(resp *http.Respon // GetUtcUppercaseMaxDateTime get max datetime value FRI, 31 DEC 9999 23:59:59 GMT func (client Datetimerfc1123Client) GetUtcUppercaseMaxDateTime(ctx context.Context) (result DateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.GetUtcUppercaseMaxDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUtcUppercaseMaxDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "GetUtcUppercaseMaxDateTime", nil, "Failure preparing request") @@ -395,6 +466,16 @@ func (client Datetimerfc1123Client) GetUtcUppercaseMaxDateTimeResponder(resp *ht // PutUtcMaxDateTime put max datetime value Fri, 31 Dec 9999 23:59:59 GMT func (client Datetimerfc1123Client) PutUtcMaxDateTime(ctx context.Context, datetimeBody date.TimeRFC1123) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.PutUtcMaxDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutUtcMaxDateTimePreparer(ctx, datetimeBody) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "PutUtcMaxDateTime", nil, "Failure preparing request") @@ -448,6 +529,16 @@ func (client Datetimerfc1123Client) PutUtcMaxDateTimeResponder(resp *http.Respon // PutUtcMinDateTime put min datetime value Mon, 1 Jan 0001 00:00:00 GMT func (client Datetimerfc1123Client) PutUtcMinDateTime(ctx context.Context, datetimeBody date.TimeRFC1123) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Datetimerfc1123Client.PutUtcMinDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutUtcMinDateTimePreparer(ctx, datetimeBody) if err != nil { err = autorest.NewErrorWithError(err, "datetimerfc1123group.Datetimerfc1123Client", "PutUtcMinDateTime", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-datetime-rfc1123/models.go b/test/src/tests/generated/body-datetime-rfc1123/models.go index af1e4890e..da0f54edf 100644 --- a/test/src/tests/generated/body-datetime-rfc1123/models.go +++ b/test/src/tests/generated/body-datetime-rfc1123/models.go @@ -11,6 +11,9 @@ import ( "github.com/Azure/go-autorest/autorest/date" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-datetime-rfc1123" + // DateTimeRfc1123 ... type DateTimeRfc1123 struct { autorest.Response `json:"-"` diff --git a/test/src/tests/generated/body-datetime/datetime.go b/test/src/tests/generated/body-datetime/datetime.go index e465f9057..5376d9dfa 100644 --- a/test/src/tests/generated/body-datetime/datetime.go +++ b/test/src/tests/generated/body-datetime/datetime.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewDatetimeClientWithBaseURI(baseURI string) DatetimeClient { // GetInvalid get invalid datetime value func (client DatetimeClient) GetInvalid(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetInvalid", nil, "Failure preparing request") @@ -84,6 +95,16 @@ func (client DatetimeClient) GetInvalidResponder(resp *http.Response) (result Da // GetLocalNegativeOffsetLowercaseMaxDateTime get max datetime value with positive num offset // 9999-12-31t23:59:59.9999999-14:00 func (client DatetimeClient) GetLocalNegativeOffsetLowercaseMaxDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetLocalNegativeOffsetLowercaseMaxDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLocalNegativeOffsetLowercaseMaxDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetLocalNegativeOffsetLowercaseMaxDateTime", nil, "Failure preparing request") @@ -136,6 +157,16 @@ func (client DatetimeClient) GetLocalNegativeOffsetLowercaseMaxDateTimeResponder // GetLocalNegativeOffsetMinDateTime get min datetime value 0001-01-01T00:00:00-14:00 func (client DatetimeClient) GetLocalNegativeOffsetMinDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetLocalNegativeOffsetMinDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLocalNegativeOffsetMinDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetLocalNegativeOffsetMinDateTime", nil, "Failure preparing request") @@ -189,6 +220,16 @@ func (client DatetimeClient) GetLocalNegativeOffsetMinDateTimeResponder(resp *ht // GetLocalNegativeOffsetUppercaseMaxDateTime get max datetime value with positive num offset // 9999-12-31T23:59:59.9999999-14:00 func (client DatetimeClient) GetLocalNegativeOffsetUppercaseMaxDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetLocalNegativeOffsetUppercaseMaxDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLocalNegativeOffsetUppercaseMaxDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetLocalNegativeOffsetUppercaseMaxDateTime", nil, "Failure preparing request") @@ -242,6 +283,16 @@ func (client DatetimeClient) GetLocalNegativeOffsetUppercaseMaxDateTimeResponder // GetLocalPositiveOffsetLowercaseMaxDateTime get max datetime value with positive num offset // 9999-12-31t23:59:59.9999999+14:00 func (client DatetimeClient) GetLocalPositiveOffsetLowercaseMaxDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetLocalPositiveOffsetLowercaseMaxDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLocalPositiveOffsetLowercaseMaxDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetLocalPositiveOffsetLowercaseMaxDateTime", nil, "Failure preparing request") @@ -294,6 +345,16 @@ func (client DatetimeClient) GetLocalPositiveOffsetLowercaseMaxDateTimeResponder // GetLocalPositiveOffsetMinDateTime get min datetime value 0001-01-01T00:00:00+14:00 func (client DatetimeClient) GetLocalPositiveOffsetMinDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetLocalPositiveOffsetMinDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLocalPositiveOffsetMinDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetLocalPositiveOffsetMinDateTime", nil, "Failure preparing request") @@ -347,6 +408,16 @@ func (client DatetimeClient) GetLocalPositiveOffsetMinDateTimeResponder(resp *ht // GetLocalPositiveOffsetUppercaseMaxDateTime get max datetime value with positive num offset // 9999-12-31T23:59:59.9999999+14:00 func (client DatetimeClient) GetLocalPositiveOffsetUppercaseMaxDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetLocalPositiveOffsetUppercaseMaxDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLocalPositiveOffsetUppercaseMaxDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetLocalPositiveOffsetUppercaseMaxDateTime", nil, "Failure preparing request") @@ -399,6 +470,16 @@ func (client DatetimeClient) GetLocalPositiveOffsetUppercaseMaxDateTimeResponder // GetNull get null datetime value func (client DatetimeClient) GetNull(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetNull", nil, "Failure preparing request") @@ -451,6 +532,16 @@ func (client DatetimeClient) GetNullResponder(resp *http.Response) (result DateT // GetOverflow get overflow datetime value func (client DatetimeClient) GetOverflow(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetOverflow") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetOverflowPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetOverflow", nil, "Failure preparing request") @@ -503,6 +594,16 @@ func (client DatetimeClient) GetOverflowResponder(resp *http.Response) (result D // GetUnderflow get underflow datetime value func (client DatetimeClient) GetUnderflow(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetUnderflow") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUnderflowPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetUnderflow", nil, "Failure preparing request") @@ -555,6 +656,16 @@ func (client DatetimeClient) GetUnderflowResponder(resp *http.Response) (result // GetUtcLowercaseMaxDateTime get max datetime value 9999-12-31t23:59:59.9999999z func (client DatetimeClient) GetUtcLowercaseMaxDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetUtcLowercaseMaxDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUtcLowercaseMaxDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetUtcLowercaseMaxDateTime", nil, "Failure preparing request") @@ -607,6 +718,16 @@ func (client DatetimeClient) GetUtcLowercaseMaxDateTimeResponder(resp *http.Resp // GetUtcMinDateTime get min datetime value 0001-01-01T00:00:00Z func (client DatetimeClient) GetUtcMinDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetUtcMinDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUtcMinDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetUtcMinDateTime", nil, "Failure preparing request") @@ -659,6 +780,16 @@ func (client DatetimeClient) GetUtcMinDateTimeResponder(resp *http.Response) (re // GetUtcUppercaseMaxDateTime get max datetime value 9999-12-31T23:59:59.9999999Z func (client DatetimeClient) GetUtcUppercaseMaxDateTime(ctx context.Context) (result DateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.GetUtcUppercaseMaxDateTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUtcUppercaseMaxDateTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "GetUtcUppercaseMaxDateTime", nil, "Failure preparing request") @@ -711,6 +842,16 @@ func (client DatetimeClient) GetUtcUppercaseMaxDateTimeResponder(resp *http.Resp // PutLocalNegativeOffsetMaxDateTime put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999-14:00 func (client DatetimeClient) PutLocalNegativeOffsetMaxDateTime(ctx context.Context, datetimeBody date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.PutLocalNegativeOffsetMaxDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutLocalNegativeOffsetMaxDateTimePreparer(ctx, datetimeBody) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "PutLocalNegativeOffsetMaxDateTime", nil, "Failure preparing request") @@ -764,6 +905,16 @@ func (client DatetimeClient) PutLocalNegativeOffsetMaxDateTimeResponder(resp *ht // PutLocalNegativeOffsetMinDateTime put min datetime value 0001-01-01T00:00:00-14:00 func (client DatetimeClient) PutLocalNegativeOffsetMinDateTime(ctx context.Context, datetimeBody date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.PutLocalNegativeOffsetMinDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutLocalNegativeOffsetMinDateTimePreparer(ctx, datetimeBody) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "PutLocalNegativeOffsetMinDateTime", nil, "Failure preparing request") @@ -817,6 +968,16 @@ func (client DatetimeClient) PutLocalNegativeOffsetMinDateTimeResponder(resp *ht // PutLocalPositiveOffsetMaxDateTime put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999+14:00 func (client DatetimeClient) PutLocalPositiveOffsetMaxDateTime(ctx context.Context, datetimeBody date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.PutLocalPositiveOffsetMaxDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutLocalPositiveOffsetMaxDateTimePreparer(ctx, datetimeBody) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "PutLocalPositiveOffsetMaxDateTime", nil, "Failure preparing request") @@ -870,6 +1031,16 @@ func (client DatetimeClient) PutLocalPositiveOffsetMaxDateTimeResponder(resp *ht // PutLocalPositiveOffsetMinDateTime put min datetime value 0001-01-01T00:00:00+14:00 func (client DatetimeClient) PutLocalPositiveOffsetMinDateTime(ctx context.Context, datetimeBody date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.PutLocalPositiveOffsetMinDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutLocalPositiveOffsetMinDateTimePreparer(ctx, datetimeBody) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "PutLocalPositiveOffsetMinDateTime", nil, "Failure preparing request") @@ -923,6 +1094,16 @@ func (client DatetimeClient) PutLocalPositiveOffsetMinDateTimeResponder(resp *ht // PutUtcMaxDateTime put max datetime value 9999-12-31T23:59:59.9999999Z func (client DatetimeClient) PutUtcMaxDateTime(ctx context.Context, datetimeBody date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.PutUtcMaxDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutUtcMaxDateTimePreparer(ctx, datetimeBody) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "PutUtcMaxDateTime", nil, "Failure preparing request") @@ -976,6 +1157,16 @@ func (client DatetimeClient) PutUtcMaxDateTimeResponder(resp *http.Response) (re // PutUtcMinDateTime put min datetime value 0001-01-01T00:00:00Z func (client DatetimeClient) PutUtcMinDateTime(ctx context.Context, datetimeBody date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DatetimeClient.PutUtcMinDateTime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutUtcMinDateTimePreparer(ctx, datetimeBody) if err != nil { err = autorest.NewErrorWithError(err, "datetimegroup.DatetimeClient", "PutUtcMinDateTime", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-datetime/models.go b/test/src/tests/generated/body-datetime/models.go index befcf36e4..ae29cadf6 100644 --- a/test/src/tests/generated/body-datetime/models.go +++ b/test/src/tests/generated/body-datetime/models.go @@ -11,6 +11,9 @@ import ( "github.com/Azure/go-autorest/autorest/date" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-datetime" + // DateTime ... type DateTime struct { autorest.Response `json:"-"` diff --git a/test/src/tests/generated/body-dictionary/dictionary.go b/test/src/tests/generated/body-dictionary/dictionary.go index 7dce5497c..7f98c0e18 100644 --- a/test/src/tests/generated/body-dictionary/dictionary.go +++ b/test/src/tests/generated/body-dictionary/dictionary.go @@ -12,6 +12,7 @@ import ( "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -32,6 +33,16 @@ func NewDictionaryClientWithBaseURI(baseURI string) DictionaryClient { // GetArrayEmpty get an empty dictionary {} func (client DictionaryClient) GetArrayEmpty(ctx context.Context) (result SetListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetArrayEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetArrayEmpty", nil, "Failure preparing request") @@ -84,6 +95,16 @@ func (client DictionaryClient) GetArrayEmptyResponder(resp *http.Response) (resu // GetArrayItemEmpty get an array of array of strings [{"0": ["1", "2", "3"], "1": [], "2": ["7", "8", "9"]} func (client DictionaryClient) GetArrayItemEmpty(ctx context.Context) (result SetListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetArrayItemEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayItemEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetArrayItemEmpty", nil, "Failure preparing request") @@ -136,6 +157,16 @@ func (client DictionaryClient) GetArrayItemEmptyResponder(resp *http.Response) ( // GetArrayItemNull get an dictionary of array of strings {"0": ["1", "2", "3"], "1": null, "2": ["7", "8", "9"]} func (client DictionaryClient) GetArrayItemNull(ctx context.Context) (result SetListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetArrayItemNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayItemNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetArrayItemNull", nil, "Failure preparing request") @@ -188,6 +219,16 @@ func (client DictionaryClient) GetArrayItemNullResponder(resp *http.Response) (r // GetArrayNull get a null array func (client DictionaryClient) GetArrayNull(ctx context.Context) (result SetListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetArrayNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetArrayNull", nil, "Failure preparing request") @@ -240,6 +281,16 @@ func (client DictionaryClient) GetArrayNullResponder(resp *http.Response) (resul // GetArrayValid get an array of array of strings {"0": ["1", "2", "3"], "1": ["4", "5", "6"], "2": ["7", "8", "9"]} func (client DictionaryClient) GetArrayValid(ctx context.Context) (result SetListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetArrayValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetArrayValid", nil, "Failure preparing request") @@ -293,6 +344,16 @@ func (client DictionaryClient) GetArrayValidResponder(resp *http.Response) (resu // GetBase64URL get base64url dictionary value {"0": "a string that gets encoded with base64url", "1": "test string", // "2": "Lorem ipsum"} func (client DictionaryClient) GetBase64URL(ctx context.Context) (result SetBase64URL, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetBase64URL") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBase64URLPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetBase64URL", nil, "Failure preparing request") @@ -345,6 +406,16 @@ func (client DictionaryClient) GetBase64URLResponder(resp *http.Response) (resul // GetBooleanInvalidNull get boolean dictionary value {"0": true, "1": null, "2": false } func (client DictionaryClient) GetBooleanInvalidNull(ctx context.Context) (result SetBool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetBooleanInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetBooleanInvalidNull", nil, "Failure preparing request") @@ -397,6 +468,16 @@ func (client DictionaryClient) GetBooleanInvalidNullResponder(resp *http.Respons // GetBooleanInvalidString get boolean dictionary value '{"0": true, "1": "boolean", "2": false}' func (client DictionaryClient) GetBooleanInvalidString(ctx context.Context) (result SetBool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetBooleanInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetBooleanInvalidString", nil, "Failure preparing request") @@ -449,6 +530,16 @@ func (client DictionaryClient) GetBooleanInvalidStringResponder(resp *http.Respo // GetBooleanTfft get boolean dictionary value {"0": true, "1": false, "2": false, "3": true } func (client DictionaryClient) GetBooleanTfft(ctx context.Context) (result SetBool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetBooleanTfft") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanTfftPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetBooleanTfft", nil, "Failure preparing request") @@ -501,6 +592,16 @@ func (client DictionaryClient) GetBooleanTfftResponder(resp *http.Response) (res // GetByteInvalidNull get byte dictionary value {"0": hex(FF FF FF FA), "1": null} with the first item base64 encoded func (client DictionaryClient) GetByteInvalidNull(ctx context.Context) (result SetByteArray, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetByteInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetByteInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetByteInvalidNull", nil, "Failure preparing request") @@ -554,6 +655,16 @@ func (client DictionaryClient) GetByteInvalidNullResponder(resp *http.Response) // GetByteValid get byte dictionary value {"0": hex(FF FF FF FA), "1": hex(01 02 03), "2": hex (25, 29, 43)} with each // item encoded in base64 func (client DictionaryClient) GetByteValid(ctx context.Context) (result SetByteArray, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetByteValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetByteValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetByteValid", nil, "Failure preparing request") @@ -606,6 +717,16 @@ func (client DictionaryClient) GetByteValidResponder(resp *http.Response) (resul // GetComplexEmpty get empty dictionary of complex type {} func (client DictionaryClient) GetComplexEmpty(ctx context.Context) (result SetWidget, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetComplexEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetComplexEmpty", nil, "Failure preparing request") @@ -659,6 +780,16 @@ func (client DictionaryClient) GetComplexEmptyResponder(resp *http.Response) (re // GetComplexItemEmpty get dictionary of complex type with empty item {"0": {"integer": 1, "string": "2"}, "1:" {}, // "2": {"integer": 5, "string": "6"}} func (client DictionaryClient) GetComplexItemEmpty(ctx context.Context) (result SetWidget, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetComplexItemEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexItemEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetComplexItemEmpty", nil, "Failure preparing request") @@ -712,6 +843,16 @@ func (client DictionaryClient) GetComplexItemEmptyResponder(resp *http.Response) // GetComplexItemNull get dictionary of complex type with null item {"0": {"integer": 1, "string": "2"}, "1": null, // "2": {"integer": 5, "string": "6"}} func (client DictionaryClient) GetComplexItemNull(ctx context.Context) (result SetWidget, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetComplexItemNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexItemNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetComplexItemNull", nil, "Failure preparing request") @@ -764,6 +905,16 @@ func (client DictionaryClient) GetComplexItemNullResponder(resp *http.Response) // GetComplexNull get dictionary of complex type null value func (client DictionaryClient) GetComplexNull(ctx context.Context) (result SetWidget, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetComplexNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetComplexNull", nil, "Failure preparing request") @@ -817,6 +968,16 @@ func (client DictionaryClient) GetComplexNullResponder(resp *http.Response) (res // GetComplexValid get dictionary of complex type with {"0": {"integer": 1, "string": "2"}, "1": {"integer": 3, // "string": "4"}, "2": {"integer": 5, "string": "6"}} func (client DictionaryClient) GetComplexValid(ctx context.Context) (result SetWidget, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetComplexValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetComplexValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetComplexValid", nil, "Failure preparing request") @@ -869,6 +1030,16 @@ func (client DictionaryClient) GetComplexValidResponder(resp *http.Response) (re // GetDateInvalidChars get date dictionary value {"0": "2011-03-22", "1": "date"} func (client DictionaryClient) GetDateInvalidChars(ctx context.Context) (result SetDate, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDateInvalidChars") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateInvalidCharsPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDateInvalidChars", nil, "Failure preparing request") @@ -921,6 +1092,16 @@ func (client DictionaryClient) GetDateInvalidCharsResponder(resp *http.Response) // GetDateInvalidNull get date dictionary value {"0": "2012-01-01", "1": null, "2": "1776-07-04"} func (client DictionaryClient) GetDateInvalidNull(ctx context.Context) (result SetDate, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDateInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDateInvalidNull", nil, "Failure preparing request") @@ -973,6 +1154,16 @@ func (client DictionaryClient) GetDateInvalidNullResponder(resp *http.Response) // GetDateTimeInvalidChars get date dictionary value {"0": "2000-12-01t00:00:01z", "1": "date-time"} func (client DictionaryClient) GetDateTimeInvalidChars(ctx context.Context) (result SetDateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDateTimeInvalidChars") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeInvalidCharsPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDateTimeInvalidChars", nil, "Failure preparing request") @@ -1025,6 +1216,16 @@ func (client DictionaryClient) GetDateTimeInvalidCharsResponder(resp *http.Respo // GetDateTimeInvalidNull get date dictionary value {"0": "2000-12-01t00:00:01z", "1": null} func (client DictionaryClient) GetDateTimeInvalidNull(ctx context.Context) (result SetDateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDateTimeInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDateTimeInvalidNull", nil, "Failure preparing request") @@ -1078,6 +1279,16 @@ func (client DictionaryClient) GetDateTimeInvalidNullResponder(resp *http.Respon // GetDateTimeRfc1123Valid get date-time-rfc1123 dictionary value {"0": "Fri, 01 Dec 2000 00:00:01 GMT", "1": "Wed, 02 // Jan 1980 00:11:35 GMT", "2": "Wed, 12 Oct 1492 10:15:01 GMT"} func (client DictionaryClient) GetDateTimeRfc1123Valid(ctx context.Context) (result SetDateTimeRfc1123, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDateTimeRfc1123Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeRfc1123ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDateTimeRfc1123Valid", nil, "Failure preparing request") @@ -1131,6 +1342,16 @@ func (client DictionaryClient) GetDateTimeRfc1123ValidResponder(resp *http.Respo // GetDateTimeValid get date-time dictionary value {"0": "2000-12-01t00:00:01z", "1": "1980-01-02T00:11:35+01:00", "2": // "1492-10-12T10:15:01-08:00"} func (client DictionaryClient) GetDateTimeValid(ctx context.Context) (result SetDateTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDateTimeValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateTimeValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDateTimeValid", nil, "Failure preparing request") @@ -1183,6 +1404,16 @@ func (client DictionaryClient) GetDateTimeValidResponder(resp *http.Response) (r // GetDateValid get integer dictionary value {"0": "2000-12-01", "1": "1980-01-02", "2": "1492-10-12"} func (client DictionaryClient) GetDateValid(ctx context.Context) (result SetDate, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDateValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDateValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDateValid", nil, "Failure preparing request") @@ -1235,6 +1466,16 @@ func (client DictionaryClient) GetDateValidResponder(resp *http.Response) (resul // GetDictionaryEmpty get an dictionaries of dictionaries of type with value {} func (client DictionaryClient) GetDictionaryEmpty(ctx context.Context) (result SetSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDictionaryEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDictionaryEmpty", nil, "Failure preparing request") @@ -1288,6 +1529,16 @@ func (client DictionaryClient) GetDictionaryEmptyResponder(resp *http.Response) // GetDictionaryItemEmpty get an dictionaries of dictionaries of type with value {"0": {"1": "one", // "2": "two", "3": "three"}, "1": {}, "2": {"7": "seven", "8": "eight", "9": "nine"}} func (client DictionaryClient) GetDictionaryItemEmpty(ctx context.Context) (result SetSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDictionaryItemEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryItemEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDictionaryItemEmpty", nil, "Failure preparing request") @@ -1341,6 +1592,16 @@ func (client DictionaryClient) GetDictionaryItemEmptyResponder(resp *http.Respon // GetDictionaryItemNull get an dictionaries of dictionaries of type with value {"0": {"1": "one", // "2": "two", "3": "three"}, "1": null, "2": {"7": "seven", "8": "eight", "9": "nine"}} func (client DictionaryClient) GetDictionaryItemNull(ctx context.Context) (result SetSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDictionaryItemNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryItemNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDictionaryItemNull", nil, "Failure preparing request") @@ -1393,6 +1654,16 @@ func (client DictionaryClient) GetDictionaryItemNullResponder(resp *http.Respons // GetDictionaryNull get an dictionaries of dictionaries with value null func (client DictionaryClient) GetDictionaryNull(ctx context.Context) (result SetSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDictionaryNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDictionaryNull", nil, "Failure preparing request") @@ -1446,6 +1717,16 @@ func (client DictionaryClient) GetDictionaryNullResponder(resp *http.Response) ( // GetDictionaryValid get an dictionaries of dictionaries of type with value {"0": {"1": "one", "2": // "two", "3": "three"}, "1": {"4": "four", "5": "five", "6": "six"}, "2": {"7": "seven", "8": "eight", "9": "nine"}} func (client DictionaryClient) GetDictionaryValid(ctx context.Context) (result SetSetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDictionaryValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDictionaryValid", nil, "Failure preparing request") @@ -1498,6 +1779,16 @@ func (client DictionaryClient) GetDictionaryValidResponder(resp *http.Response) // GetDoubleInvalidNull get float dictionary value {"0": 0.0, "1": null, "2": 1.2e20} func (client DictionaryClient) GetDoubleInvalidNull(ctx context.Context) (result SetFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDoubleInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDoubleInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDoubleInvalidNull", nil, "Failure preparing request") @@ -1550,6 +1841,16 @@ func (client DictionaryClient) GetDoubleInvalidNullResponder(resp *http.Response // GetDoubleInvalidString get boolean dictionary value {"0": 1.0, "1": "number", "2": 0.0} func (client DictionaryClient) GetDoubleInvalidString(ctx context.Context) (result SetFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDoubleInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDoubleInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDoubleInvalidString", nil, "Failure preparing request") @@ -1602,6 +1903,16 @@ func (client DictionaryClient) GetDoubleInvalidStringResponder(resp *http.Respon // GetDoubleValid get float dictionary value {"0": 0, "1": -0.01, "2": 1.2e20} func (client DictionaryClient) GetDoubleValid(ctx context.Context) (result SetFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDoubleValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDoubleValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDoubleValid", nil, "Failure preparing request") @@ -1654,6 +1965,16 @@ func (client DictionaryClient) GetDoubleValidResponder(resp *http.Response) (res // GetDurationValid get duration dictionary value {"0": "P123DT22H14M12.011S", "1": "P5DT1H0M0S"} func (client DictionaryClient) GetDurationValid(ctx context.Context) (result SetTimeSpan, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetDurationValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDurationValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetDurationValid", nil, "Failure preparing request") @@ -1706,6 +2027,16 @@ func (client DictionaryClient) GetDurationValidResponder(resp *http.Response) (r // GetEmpty get empty dictionary value {} func (client DictionaryClient) GetEmpty(ctx context.Context) (result SetInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetEmpty", nil, "Failure preparing request") @@ -1758,6 +2089,16 @@ func (client DictionaryClient) GetEmptyResponder(resp *http.Response) (result Se // GetEmptyStringKey get Dictionary with key as empty string func (client DictionaryClient) GetEmptyStringKey(ctx context.Context) (result SetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetEmptyStringKey") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyStringKeyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetEmptyStringKey", nil, "Failure preparing request") @@ -1810,6 +2151,16 @@ func (client DictionaryClient) GetEmptyStringKeyResponder(resp *http.Response) ( // GetFloatInvalidNull get float dictionary value {"0": 0.0, "1": null, "2": 1.2e20} func (client DictionaryClient) GetFloatInvalidNull(ctx context.Context) (result SetFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetFloatInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFloatInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetFloatInvalidNull", nil, "Failure preparing request") @@ -1862,6 +2213,16 @@ func (client DictionaryClient) GetFloatInvalidNullResponder(resp *http.Response) // GetFloatInvalidString get boolean dictionary value {"0": 1.0, "1": "number", "2": 0.0} func (client DictionaryClient) GetFloatInvalidString(ctx context.Context) (result SetFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetFloatInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFloatInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetFloatInvalidString", nil, "Failure preparing request") @@ -1914,6 +2275,16 @@ func (client DictionaryClient) GetFloatInvalidStringResponder(resp *http.Respons // GetFloatValid get float dictionary value {"0": 0, "1": -0.01, "2": 1.2e20} func (client DictionaryClient) GetFloatValid(ctx context.Context) (result SetFloat64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetFloatValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFloatValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetFloatValid", nil, "Failure preparing request") @@ -1966,6 +2337,16 @@ func (client DictionaryClient) GetFloatValidResponder(resp *http.Response) (resu // GetIntegerValid get integer dictionary value {"0": 1, "1": -1, "2": 3, "3": 300} func (client DictionaryClient) GetIntegerValid(ctx context.Context) (result SetInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetIntegerValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntegerValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetIntegerValid", nil, "Failure preparing request") @@ -2018,6 +2399,16 @@ func (client DictionaryClient) GetIntegerValidResponder(resp *http.Response) (re // GetIntInvalidNull get integer dictionary value {"0": 1, "1": null, "2": 0} func (client DictionaryClient) GetIntInvalidNull(ctx context.Context) (result SetInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetIntInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetIntInvalidNull", nil, "Failure preparing request") @@ -2070,6 +2461,16 @@ func (client DictionaryClient) GetIntInvalidNullResponder(resp *http.Response) ( // GetIntInvalidString get integer dictionary value {"0": 1, "1": "integer", "2": 0} func (client DictionaryClient) GetIntInvalidString(ctx context.Context) (result SetInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetIntInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetIntInvalidString", nil, "Failure preparing request") @@ -2122,6 +2523,16 @@ func (client DictionaryClient) GetIntInvalidStringResponder(resp *http.Response) // GetInvalid get invalid Dictionary value func (client DictionaryClient) GetInvalid(ctx context.Context) (result SetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetInvalid", nil, "Failure preparing request") @@ -2174,6 +2585,16 @@ func (client DictionaryClient) GetInvalidResponder(resp *http.Response) (result // GetLongInvalidNull get long dictionary value {"0": 1, "1": null, "2": 0} func (client DictionaryClient) GetLongInvalidNull(ctx context.Context) (result SetInt64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetLongInvalidNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLongInvalidNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetLongInvalidNull", nil, "Failure preparing request") @@ -2226,6 +2647,16 @@ func (client DictionaryClient) GetLongInvalidNullResponder(resp *http.Response) // GetLongInvalidString get long dictionary value {"0": 1, "1": "integer", "2": 0} func (client DictionaryClient) GetLongInvalidString(ctx context.Context) (result SetInt64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetLongInvalidString") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLongInvalidStringPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetLongInvalidString", nil, "Failure preparing request") @@ -2278,6 +2709,16 @@ func (client DictionaryClient) GetLongInvalidStringResponder(resp *http.Response // GetLongValid get integer dictionary value {"0": 1, "1": -1, "2": 3, "3": 300} func (client DictionaryClient) GetLongValid(ctx context.Context) (result SetInt64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetLongValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLongValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetLongValid", nil, "Failure preparing request") @@ -2330,6 +2771,16 @@ func (client DictionaryClient) GetLongValidResponder(resp *http.Response) (resul // GetNull get null dictionary value func (client DictionaryClient) GetNull(ctx context.Context) (result SetInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetNull", nil, "Failure preparing request") @@ -2382,6 +2833,16 @@ func (client DictionaryClient) GetNullResponder(resp *http.Response) (result Set // GetNullKey get Dictionary with null key func (client DictionaryClient) GetNullKey(ctx context.Context) (result SetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetNullKey") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullKeyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetNullKey", nil, "Failure preparing request") @@ -2434,6 +2895,16 @@ func (client DictionaryClient) GetNullKeyResponder(resp *http.Response) (result // GetNullValue get Dictionary with null value func (client DictionaryClient) GetNullValue(ctx context.Context) (result SetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetNullValue") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullValuePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetNullValue", nil, "Failure preparing request") @@ -2486,6 +2957,16 @@ func (client DictionaryClient) GetNullValueResponder(resp *http.Response) (resul // GetStringValid get string dictionary value {"0": "foo1", "1": "foo2", "2": "foo3"} func (client DictionaryClient) GetStringValid(ctx context.Context) (result SetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetStringValid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetStringValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetStringValid", nil, "Failure preparing request") @@ -2538,6 +3019,16 @@ func (client DictionaryClient) GetStringValidResponder(resp *http.Response) (res // GetStringWithInvalid get string dictionary value {"0": "foo", "1": 123, "2": "foo2"} func (client DictionaryClient) GetStringWithInvalid(ctx context.Context) (result SetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetStringWithInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetStringWithInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetStringWithInvalid", nil, "Failure preparing request") @@ -2590,6 +3081,16 @@ func (client DictionaryClient) GetStringWithInvalidResponder(resp *http.Response // GetStringWithNull get string dictionary value {"0": "foo", "1": null, "2": "foo2"} func (client DictionaryClient) GetStringWithNull(ctx context.Context) (result SetString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.GetStringWithNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetStringWithNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "dictionarygroup.DictionaryClient", "GetStringWithNull", nil, "Failure preparing request") @@ -2642,6 +3143,16 @@ func (client DictionaryClient) GetStringWithNullResponder(resp *http.Response) ( // PutArrayValid put An array of array of strings {"0": ["1", "2", "3"], "1": ["4", "5", "6"], "2": ["7", "8", "9"]} func (client DictionaryClient) PutArrayValid(ctx context.Context, arrayBody map[string][]string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutArrayValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2701,6 +3212,16 @@ func (client DictionaryClient) PutArrayValidResponder(resp *http.Response) (resu // PutBooleanTfft set dictionary value empty {"0": true, "1": false, "2": false, "3": true } func (client DictionaryClient) PutBooleanTfft(ctx context.Context, arrayBody map[string]*bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutBooleanTfft") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2761,6 +3282,16 @@ func (client DictionaryClient) PutBooleanTfftResponder(resp *http.Response) (res // PutByteValid put the dictionary value {"0": hex(FF FF FF FA), "1": hex(01 02 03), "2": hex (25, 29, 43)} with each // elementencoded in base 64 func (client DictionaryClient) PutByteValid(ctx context.Context, arrayBody map[string][]byte) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutByteValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2821,6 +3352,16 @@ func (client DictionaryClient) PutByteValidResponder(resp *http.Response) (resul // PutComplexValid put an dictionary of complex type with values {"0": {"integer": 1, "string": "2"}, "1": {"integer": // 3, "string": "4"}, "2": {"integer": 5, "string": "6"}} func (client DictionaryClient) PutComplexValid(ctx context.Context, arrayBody map[string]*Widget) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutComplexValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2881,6 +3422,16 @@ func (client DictionaryClient) PutComplexValidResponder(resp *http.Response) (re // PutDateTimeRfc1123Valid set dictionary value empty {"0": "Fri, 01 Dec 2000 00:00:01 GMT", "1": "Wed, 02 Jan 1980 // 00:11:35 GMT", "2": "Wed, 12 Oct 1492 10:15:01 GMT"} func (client DictionaryClient) PutDateTimeRfc1123Valid(ctx context.Context, arrayBody map[string]*date.TimeRFC1123) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutDateTimeRfc1123Valid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -2941,6 +3492,16 @@ func (client DictionaryClient) PutDateTimeRfc1123ValidResponder(resp *http.Respo // PutDateTimeValid set dictionary value {"0": "2000-12-01t00:00:01z", "1": "1980-01-02T00:11:35+01:00", "2": // "1492-10-12T10:15:01-08:00"} func (client DictionaryClient) PutDateTimeValid(ctx context.Context, arrayBody map[string]*date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutDateTimeValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3000,6 +3561,16 @@ func (client DictionaryClient) PutDateTimeValidResponder(resp *http.Response) (r // PutDateValid set dictionary value {"0": "2000-12-01", "1": "1980-01-02", "2": "1492-10-12"} func (client DictionaryClient) PutDateValid(ctx context.Context, arrayBody map[string]*date.Date) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutDateValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3060,6 +3631,16 @@ func (client DictionaryClient) PutDateValidResponder(resp *http.Response) (resul // PutDictionaryValid get an dictionaries of dictionaries of type with value {"0": {"1": "one", "2": // "two", "3": "three"}, "1": {"4": "four", "5": "five", "6": "six"}, "2": {"7": "seven", "8": "eight", "9": "nine"}} func (client DictionaryClient) PutDictionaryValid(ctx context.Context, arrayBody map[string]map[string]*string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutDictionaryValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3119,6 +3700,16 @@ func (client DictionaryClient) PutDictionaryValidResponder(resp *http.Response) // PutDoubleValid set dictionary value {"0": 0, "1": -0.01, "2": 1.2e20} func (client DictionaryClient) PutDoubleValid(ctx context.Context, arrayBody map[string]*float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutDoubleValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3178,6 +3769,16 @@ func (client DictionaryClient) PutDoubleValidResponder(resp *http.Response) (res // PutDurationValid set dictionary value {"0": "P123DT22H14M12.011S", "1": "P5DT1H0M0S"} func (client DictionaryClient) PutDurationValid(ctx context.Context, arrayBody map[string]*string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutDurationValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3237,6 +3838,16 @@ func (client DictionaryClient) PutDurationValidResponder(resp *http.Response) (r // PutEmpty set dictionary value empty {} func (client DictionaryClient) PutEmpty(ctx context.Context, arrayBody map[string]*string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3296,6 +3907,16 @@ func (client DictionaryClient) PutEmptyResponder(resp *http.Response) (result au // PutFloatValid set dictionary value {"0": 0, "1": -0.01, "2": 1.2e20} func (client DictionaryClient) PutFloatValid(ctx context.Context, arrayBody map[string]*float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutFloatValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3355,6 +3976,16 @@ func (client DictionaryClient) PutFloatValidResponder(resp *http.Response) (resu // PutIntegerValid set dictionary value empty {"0": 1, "1": -1, "2": 3, "3": 300} func (client DictionaryClient) PutIntegerValid(ctx context.Context, arrayBody map[string]*int32) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutIntegerValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3414,6 +4045,16 @@ func (client DictionaryClient) PutIntegerValidResponder(resp *http.Response) (re // PutLongValid set dictionary value empty {"0": 1, "1": -1, "2": 3, "3": 300} func (client DictionaryClient) PutLongValid(ctx context.Context, arrayBody map[string]*int64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutLongValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -3473,6 +4114,16 @@ func (client DictionaryClient) PutLongValidResponder(resp *http.Response) (resul // PutStringValid set dictionary value {"0": "foo1", "1": "foo2", "2": "foo3"} func (client DictionaryClient) PutStringValid(ctx context.Context, arrayBody map[string]*string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DictionaryClient.PutStringValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayBody, Constraints: []validation.Constraint{{Target: "arrayBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { diff --git a/test/src/tests/generated/body-dictionary/models.go b/test/src/tests/generated/body-dictionary/models.go index 152d32e17..be3e1873a 100644 --- a/test/src/tests/generated/body-dictionary/models.go +++ b/test/src/tests/generated/body-dictionary/models.go @@ -12,6 +12,9 @@ import ( "github.com/Azure/go-autorest/autorest/date" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-dictionary" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/body-duration/duration.go b/test/src/tests/generated/body-duration/duration.go index ad4639b1e..63f761cd8 100644 --- a/test/src/tests/generated/body-duration/duration.go +++ b/test/src/tests/generated/body-duration/duration.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewDurationClientWithBaseURI(baseURI string) DurationClient { // GetInvalid get an invalid duration value func (client DurationClient) GetInvalid(ctx context.Context) (result TimeSpan, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DurationClient.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "durationgroup.DurationClient", "GetInvalid", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client DurationClient) GetInvalidResponder(resp *http.Response) (result Ti // GetNull get null duration value func (client DurationClient) GetNull(ctx context.Context) (result TimeSpan, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DurationClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "durationgroup.DurationClient", "GetNull", nil, "Failure preparing request") @@ -134,6 +155,16 @@ func (client DurationClient) GetNullResponder(resp *http.Response) (result TimeS // GetPositiveDuration get a positive duration value func (client DurationClient) GetPositiveDuration(ctx context.Context) (result TimeSpan, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DurationClient.GetPositiveDuration") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetPositiveDurationPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "durationgroup.DurationClient", "GetPositiveDuration", nil, "Failure preparing request") @@ -186,6 +217,16 @@ func (client DurationClient) GetPositiveDurationResponder(resp *http.Response) ( // PutPositiveDuration put a positive duration value func (client DurationClient) PutPositiveDuration(ctx context.Context, durationBody string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DurationClient.PutPositiveDuration") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutPositiveDurationPreparer(ctx, durationBody) if err != nil { err = autorest.NewErrorWithError(err, "durationgroup.DurationClient", "PutPositiveDuration", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-duration/models.go b/test/src/tests/generated/body-duration/models.go index 1152c9214..bd35b6ece 100644 --- a/test/src/tests/generated/body-duration/models.go +++ b/test/src/tests/generated/body-duration/models.go @@ -10,6 +10,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-duration" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/body-file/files.go b/test/src/tests/generated/body-file/files.go index 370e901af..42f33ca1d 100644 --- a/test/src/tests/generated/body-file/files.go +++ b/test/src/tests/generated/body-file/files.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewFilesClientWithBaseURI(baseURI string) FilesClient { // GetEmptyFile get empty file func (client FilesClient) GetEmptyFile(ctx context.Context) (result ReadCloser, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/FilesClient.GetEmptyFile") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyFilePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "filegroup.FilesClient", "GetEmptyFile", nil, "Failure preparing request") @@ -81,6 +92,16 @@ func (client FilesClient) GetEmptyFileResponder(resp *http.Response) (result Rea // GetFile get file func (client FilesClient) GetFile(ctx context.Context) (result ReadCloser, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/FilesClient.GetFile") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFilePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "filegroup.FilesClient", "GetFile", nil, "Failure preparing request") @@ -132,6 +153,16 @@ func (client FilesClient) GetFileResponder(resp *http.Response) (result ReadClos // GetFileLarge get a large file func (client FilesClient) GetFileLarge(ctx context.Context) (result ReadCloser, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/FilesClient.GetFileLarge") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetFileLargePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "filegroup.FilesClient", "GetFileLarge", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-file/models.go b/test/src/tests/generated/body-file/models.go index 94420d7d2..59822fbaf 100644 --- a/test/src/tests/generated/body-file/models.go +++ b/test/src/tests/generated/body-file/models.go @@ -11,6 +11,9 @@ import ( "io" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-file" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/body-formdata/formdata.go b/test/src/tests/generated/body-formdata/formdata.go index 0e509d2c7..0ec73a661 100644 --- a/test/src/tests/generated/body-formdata/formdata.go +++ b/test/src/tests/generated/body-formdata/formdata.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "io" "net/http" ) @@ -34,6 +35,16 @@ func NewFormdataClientWithBaseURI(baseURI string) FormdataClient { // fileContent - file to upload. // fileName - file name to upload. Name has to be spelled exactly as written here. func (client FormdataClient) UploadFile(ctx context.Context, fileContent io.ReadCloser, fileName string) (result ReadCloser, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/FormdataClient.UploadFile") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.UploadFilePreparer(ctx, fileContent, fileName) if err != nil { err = autorest.NewErrorWithError(err, "formdatagroup.FormdataClient", "UploadFile", nil, "Failure preparing request") @@ -93,6 +104,16 @@ func (client FormdataClient) UploadFileResponder(resp *http.Response) (result Re // Parameters: // fileContent - file to upload. func (client FormdataClient) UploadFileViaBody(ctx context.Context, fileContent io.ReadCloser) (result ReadCloser, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/FormdataClient.UploadFileViaBody") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.UploadFileViaBodyPreparer(ctx, fileContent) if err != nil { err = autorest.NewErrorWithError(err, "formdatagroup.FormdataClient", "UploadFileViaBody", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-formdata/models.go b/test/src/tests/generated/body-formdata/models.go index 4a8f0bbc8..97a6888dd 100644 --- a/test/src/tests/generated/body-formdata/models.go +++ b/test/src/tests/generated/body-formdata/models.go @@ -11,6 +11,9 @@ import ( "io" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-formdata" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/body-integer/int.go b/test/src/tests/generated/body-integer/int.go index ff55095be..49bacfdc7 100644 --- a/test/src/tests/generated/body-integer/int.go +++ b/test/src/tests/generated/body-integer/int.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewIntClientWithBaseURI(baseURI string) IntClient { // GetInvalid get invalid Int value func (client IntClient) GetInvalid(ctx context.Context) (result Int32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetInvalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetInvalid", nil, "Failure preparing request") @@ -83,6 +94,16 @@ func (client IntClient) GetInvalidResponder(resp *http.Response) (result Int32, // GetInvalidUnixTime get invalid Unix time value func (client IntClient) GetInvalidUnixTime(ctx context.Context) (result UnixTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetInvalidUnixTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidUnixTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetInvalidUnixTime", nil, "Failure preparing request") @@ -135,6 +156,16 @@ func (client IntClient) GetInvalidUnixTimeResponder(resp *http.Response) (result // GetNull get null Int value func (client IntClient) GetNull(ctx context.Context) (result Int32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetNull", nil, "Failure preparing request") @@ -187,6 +218,16 @@ func (client IntClient) GetNullResponder(resp *http.Response) (result Int32, err // GetNullUnixTime get null Unix time value func (client IntClient) GetNullUnixTime(ctx context.Context) (result UnixTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetNullUnixTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullUnixTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetNullUnixTime", nil, "Failure preparing request") @@ -239,6 +280,16 @@ func (client IntClient) GetNullUnixTimeResponder(resp *http.Response) (result Un // GetOverflowInt32 get overflow Int32 value func (client IntClient) GetOverflowInt32(ctx context.Context) (result Int32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetOverflowInt32") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetOverflowInt32Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetOverflowInt32", nil, "Failure preparing request") @@ -291,6 +342,16 @@ func (client IntClient) GetOverflowInt32Responder(resp *http.Response) (result I // GetOverflowInt64 get overflow Int64 value func (client IntClient) GetOverflowInt64(ctx context.Context) (result Int64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetOverflowInt64") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetOverflowInt64Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetOverflowInt64", nil, "Failure preparing request") @@ -343,6 +404,16 @@ func (client IntClient) GetOverflowInt64Responder(resp *http.Response) (result I // GetUnderflowInt32 get underflow Int32 value func (client IntClient) GetUnderflowInt32(ctx context.Context) (result Int32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetUnderflowInt32") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUnderflowInt32Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetUnderflowInt32", nil, "Failure preparing request") @@ -395,6 +466,16 @@ func (client IntClient) GetUnderflowInt32Responder(resp *http.Response) (result // GetUnderflowInt64 get underflow Int64 value func (client IntClient) GetUnderflowInt64(ctx context.Context) (result Int64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetUnderflowInt64") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUnderflowInt64Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetUnderflowInt64", nil, "Failure preparing request") @@ -447,6 +528,16 @@ func (client IntClient) GetUnderflowInt64Responder(resp *http.Response) (result // GetUnixTime get datetime encoded as Unix time value func (client IntClient) GetUnixTime(ctx context.Context) (result UnixTime, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.GetUnixTime") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetUnixTimePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "GetUnixTime", nil, "Failure preparing request") @@ -499,6 +590,16 @@ func (client IntClient) GetUnixTimeResponder(resp *http.Response) (result UnixTi // PutMax32 put max int32 value func (client IntClient) PutMax32(ctx context.Context, intBody int32) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.PutMax32") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutMax32Preparer(ctx, intBody) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "PutMax32", nil, "Failure preparing request") @@ -552,6 +653,16 @@ func (client IntClient) PutMax32Responder(resp *http.Response) (result autorest. // PutMax64 put max int64 value func (client IntClient) PutMax64(ctx context.Context, intBody int64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.PutMax64") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutMax64Preparer(ctx, intBody) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "PutMax64", nil, "Failure preparing request") @@ -605,6 +716,16 @@ func (client IntClient) PutMax64Responder(resp *http.Response) (result autorest. // PutMin32 put min int32 value func (client IntClient) PutMin32(ctx context.Context, intBody int32) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.PutMin32") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutMin32Preparer(ctx, intBody) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "PutMin32", nil, "Failure preparing request") @@ -658,6 +779,16 @@ func (client IntClient) PutMin32Responder(resp *http.Response) (result autorest. // PutMin64 put min int64 value func (client IntClient) PutMin64(ctx context.Context, intBody int64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.PutMin64") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutMin64Preparer(ctx, intBody) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "PutMin64", nil, "Failure preparing request") @@ -711,6 +842,16 @@ func (client IntClient) PutMin64Responder(resp *http.Response) (result autorest. // PutUnixTimeDate put datetime encoded as Unix time func (client IntClient) PutUnixTimeDate(ctx context.Context, intBody date.UnixTime) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/IntClient.PutUnixTimeDate") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutUnixTimeDatePreparer(ctx, intBody) if err != nil { err = autorest.NewErrorWithError(err, "integergroup.IntClient", "PutUnixTimeDate", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-integer/models.go b/test/src/tests/generated/body-integer/models.go index 97d12df0c..a23f01edc 100644 --- a/test/src/tests/generated/body-integer/models.go +++ b/test/src/tests/generated/body-integer/models.go @@ -11,6 +11,9 @@ import ( "github.com/Azure/go-autorest/autorest/date" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-integer" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/body-number/models.go b/test/src/tests/generated/body-number/models.go index e93c498df..374e104de 100644 --- a/test/src/tests/generated/body-number/models.go +++ b/test/src/tests/generated/body-number/models.go @@ -11,6 +11,9 @@ import ( "github.com/shopspring/decimal" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-number" + // Decimal ... type Decimal struct { autorest.Response `json:"-"` diff --git a/test/src/tests/generated/body-number/number.go b/test/src/tests/generated/body-number/number.go index 530229d43..acbd53d8d 100644 --- a/test/src/tests/generated/body-number/number.go +++ b/test/src/tests/generated/body-number/number.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "github.com/shopspring/decimal" "net/http" ) @@ -31,6 +32,16 @@ func NewNumberClientWithBaseURI(baseURI string) NumberClient { // GetBigDecimal get big decimal value 2.5976931e+101 func (client NumberClient) GetBigDecimal(ctx context.Context) (result Decimal, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetBigDecimal") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBigDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetBigDecimal", nil, "Failure preparing request") @@ -83,6 +94,16 @@ func (client NumberClient) GetBigDecimalResponder(resp *http.Response) (result D // GetBigDecimalNegativeDecimal get big decimal value -99999999.99 func (client NumberClient) GetBigDecimalNegativeDecimal(ctx context.Context) (result Decimal, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetBigDecimalNegativeDecimal") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBigDecimalNegativeDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetBigDecimalNegativeDecimal", nil, "Failure preparing request") @@ -135,6 +156,16 @@ func (client NumberClient) GetBigDecimalNegativeDecimalResponder(resp *http.Resp // GetBigDecimalPositiveDecimal get big decimal value 99999999.99 func (client NumberClient) GetBigDecimalPositiveDecimal(ctx context.Context) (result Decimal, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetBigDecimalPositiveDecimal") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBigDecimalPositiveDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetBigDecimalPositiveDecimal", nil, "Failure preparing request") @@ -187,6 +218,16 @@ func (client NumberClient) GetBigDecimalPositiveDecimalResponder(resp *http.Resp // GetBigDouble get big double value 2.5976931e+101 func (client NumberClient) GetBigDouble(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetBigDouble") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBigDoublePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetBigDouble", nil, "Failure preparing request") @@ -239,6 +280,16 @@ func (client NumberClient) GetBigDoubleResponder(resp *http.Response) (result Fl // GetBigDoubleNegativeDecimal get big double value -99999999.99 func (client NumberClient) GetBigDoubleNegativeDecimal(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetBigDoubleNegativeDecimal") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBigDoubleNegativeDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetBigDoubleNegativeDecimal", nil, "Failure preparing request") @@ -291,6 +342,16 @@ func (client NumberClient) GetBigDoubleNegativeDecimalResponder(resp *http.Respo // GetBigDoublePositiveDecimal get big double value 99999999.99 func (client NumberClient) GetBigDoublePositiveDecimal(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetBigDoublePositiveDecimal") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBigDoublePositiveDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetBigDoublePositiveDecimal", nil, "Failure preparing request") @@ -343,6 +404,16 @@ func (client NumberClient) GetBigDoublePositiveDecimalResponder(resp *http.Respo // GetBigFloat get big float value 3.402823e+20 func (client NumberClient) GetBigFloat(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetBigFloat") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBigFloatPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetBigFloat", nil, "Failure preparing request") @@ -395,6 +466,16 @@ func (client NumberClient) GetBigFloatResponder(resp *http.Response) (result Flo // GetInvalidDecimal get invalid decimal Number value func (client NumberClient) GetInvalidDecimal(ctx context.Context) (result Decimal, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetInvalidDecimal") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetInvalidDecimal", nil, "Failure preparing request") @@ -447,6 +528,16 @@ func (client NumberClient) GetInvalidDecimalResponder(resp *http.Response) (resu // GetInvalidDouble get invalid double Number value func (client NumberClient) GetInvalidDouble(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetInvalidDouble") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidDoublePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetInvalidDouble", nil, "Failure preparing request") @@ -499,6 +590,16 @@ func (client NumberClient) GetInvalidDoubleResponder(resp *http.Response) (resul // GetInvalidFloat get invalid float Number value func (client NumberClient) GetInvalidFloat(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetInvalidFloat") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetInvalidFloatPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetInvalidFloat", nil, "Failure preparing request") @@ -551,6 +652,16 @@ func (client NumberClient) GetInvalidFloatResponder(resp *http.Response) (result // GetNull get null Number value func (client NumberClient) GetNull(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetNull", nil, "Failure preparing request") @@ -603,6 +714,16 @@ func (client NumberClient) GetNullResponder(resp *http.Response) (result Float64 // GetSmallDecimal get small decimal value 2.5976931e-101 func (client NumberClient) GetSmallDecimal(ctx context.Context) (result Decimal, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetSmallDecimal") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetSmallDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetSmallDecimal", nil, "Failure preparing request") @@ -655,6 +776,16 @@ func (client NumberClient) GetSmallDecimalResponder(resp *http.Response) (result // GetSmallDouble get big double value 2.5976931e-101 func (client NumberClient) GetSmallDouble(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetSmallDouble") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetSmallDoublePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetSmallDouble", nil, "Failure preparing request") @@ -707,6 +838,16 @@ func (client NumberClient) GetSmallDoubleResponder(resp *http.Response) (result // GetSmallFloat get big double value 3.402823e-20 func (client NumberClient) GetSmallFloat(ctx context.Context) (result Float64, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.GetSmallFloat") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetSmallFloatPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "GetSmallFloat", nil, "Failure preparing request") @@ -759,6 +900,16 @@ func (client NumberClient) GetSmallFloatResponder(resp *http.Response) (result F // PutBigDecimal put big decimal value 2.5976931e+101 func (client NumberClient) PutBigDecimal(ctx context.Context, numberBody decimal.Decimal) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutBigDecimal") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBigDecimalPreparer(ctx, numberBody) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutBigDecimal", nil, "Failure preparing request") @@ -812,6 +963,16 @@ func (client NumberClient) PutBigDecimalResponder(resp *http.Response) (result a // PutBigDecimalNegativeDecimal put big decimal value -99999999.99 func (client NumberClient) PutBigDecimalNegativeDecimal(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutBigDecimalNegativeDecimal") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBigDecimalNegativeDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutBigDecimalNegativeDecimal", nil, "Failure preparing request") @@ -865,6 +1026,16 @@ func (client NumberClient) PutBigDecimalNegativeDecimalResponder(resp *http.Resp // PutBigDecimalPositiveDecimal put big decimal value 99999999.99 func (client NumberClient) PutBigDecimalPositiveDecimal(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutBigDecimalPositiveDecimal") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBigDecimalPositiveDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutBigDecimalPositiveDecimal", nil, "Failure preparing request") @@ -918,6 +1089,16 @@ func (client NumberClient) PutBigDecimalPositiveDecimalResponder(resp *http.Resp // PutBigDouble put big double value 2.5976931e+101 func (client NumberClient) PutBigDouble(ctx context.Context, numberBody float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutBigDouble") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBigDoublePreparer(ctx, numberBody) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutBigDouble", nil, "Failure preparing request") @@ -971,6 +1152,16 @@ func (client NumberClient) PutBigDoubleResponder(resp *http.Response) (result au // PutBigDoubleNegativeDecimal put big double value -99999999.99 func (client NumberClient) PutBigDoubleNegativeDecimal(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutBigDoubleNegativeDecimal") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBigDoubleNegativeDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutBigDoubleNegativeDecimal", nil, "Failure preparing request") @@ -1024,6 +1215,16 @@ func (client NumberClient) PutBigDoubleNegativeDecimalResponder(resp *http.Respo // PutBigDoublePositiveDecimal put big double value 99999999.99 func (client NumberClient) PutBigDoublePositiveDecimal(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutBigDoublePositiveDecimal") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBigDoublePositiveDecimalPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutBigDoublePositiveDecimal", nil, "Failure preparing request") @@ -1077,6 +1278,16 @@ func (client NumberClient) PutBigDoublePositiveDecimalResponder(resp *http.Respo // PutBigFloat put big float value 3.402823e+20 func (client NumberClient) PutBigFloat(ctx context.Context, numberBody float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutBigFloat") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBigFloatPreparer(ctx, numberBody) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutBigFloat", nil, "Failure preparing request") @@ -1130,6 +1341,16 @@ func (client NumberClient) PutBigFloatResponder(resp *http.Response) (result aut // PutSmallDecimal put small decimal value 2.5976931e-101 func (client NumberClient) PutSmallDecimal(ctx context.Context, numberBody decimal.Decimal) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutSmallDecimal") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutSmallDecimalPreparer(ctx, numberBody) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutSmallDecimal", nil, "Failure preparing request") @@ -1183,6 +1404,16 @@ func (client NumberClient) PutSmallDecimalResponder(resp *http.Response) (result // PutSmallDouble put small double value 2.5976931e-101 func (client NumberClient) PutSmallDouble(ctx context.Context, numberBody float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutSmallDouble") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutSmallDoublePreparer(ctx, numberBody) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutSmallDouble", nil, "Failure preparing request") @@ -1236,6 +1467,16 @@ func (client NumberClient) PutSmallDoubleResponder(resp *http.Response) (result // PutSmallFloat put small float value 3.402823e-20 func (client NumberClient) PutSmallFloat(ctx context.Context, numberBody float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/NumberClient.PutSmallFloat") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutSmallFloatPreparer(ctx, numberBody) if err != nil { err = autorest.NewErrorWithError(err, "numbergroup.NumberClient", "PutSmallFloat", nil, "Failure preparing request") diff --git a/test/src/tests/generated/body-string/enum.go b/test/src/tests/generated/body-string/enum.go index 3cfd1b647..135844eb0 100644 --- a/test/src/tests/generated/body-string/enum.go +++ b/test/src/tests/generated/body-string/enum.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewEnumClientWithBaseURI(baseURI string) EnumClient { // GetNotExpandable get enum value 'red color' from enumeration of 'red color', 'green-color', 'blue_color'. func (client EnumClient) GetNotExpandable(ctx context.Context) (result StringModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EnumClient.GetNotExpandable") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNotExpandablePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.EnumClient", "GetNotExpandable", nil, "Failure preparing request") @@ -83,6 +94,16 @@ func (client EnumClient) GetNotExpandableResponder(resp *http.Response) (result // GetReferenced get enum value 'red color' from enumeration of 'red color', 'green-color', 'blue_color'. func (client EnumClient) GetReferenced(ctx context.Context) (result StringModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EnumClient.GetReferenced") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetReferencedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.EnumClient", "GetReferenced", nil, "Failure preparing request") @@ -135,6 +156,16 @@ func (client EnumClient) GetReferencedResponder(resp *http.Response) (result Str // GetReferencedConstant get value 'green-color' from the constant. func (client EnumClient) GetReferencedConstant(ctx context.Context) (result RefColorConstant, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EnumClient.GetReferencedConstant") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetReferencedConstantPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.EnumClient", "GetReferencedConstant", nil, "Failure preparing request") @@ -187,6 +218,16 @@ func (client EnumClient) GetReferencedConstantResponder(resp *http.Response) (re // PutNotExpandable sends value 'red color' from enumeration of 'red color', 'green-color', 'blue_color' func (client EnumClient) PutNotExpandable(ctx context.Context, stringBody Colors) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EnumClient.PutNotExpandable") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutNotExpandablePreparer(ctx, stringBody) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.EnumClient", "PutNotExpandable", nil, "Failure preparing request") @@ -240,6 +281,16 @@ func (client EnumClient) PutNotExpandableResponder(resp *http.Response) (result // PutReferenced sends value 'red color' from enumeration of 'red color', 'green-color', 'blue_color' func (client EnumClient) PutReferenced(ctx context.Context, enumStringBody Colors) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EnumClient.PutReferenced") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutReferencedPreparer(ctx, enumStringBody) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.EnumClient", "PutReferenced", nil, "Failure preparing request") @@ -293,6 +344,16 @@ func (client EnumClient) PutReferencedResponder(resp *http.Response) (result aut // PutReferencedConstant sends value 'green-color' from a constant func (client EnumClient) PutReferencedConstant(ctx context.Context, enumStringBody RefColorConstant) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EnumClient.PutReferencedConstant") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: enumStringBody, Constraints: []validation.Constraint{{Target: "enumStringBody.ColorConstant", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { diff --git a/test/src/tests/generated/body-string/models.go b/test/src/tests/generated/body-string/models.go index 5db034677..3da1e05d5 100644 --- a/test/src/tests/generated/body-string/models.go +++ b/test/src/tests/generated/body-string/models.go @@ -10,6 +10,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/body-string" + // Colors enumerates the values for colors. type Colors string diff --git a/test/src/tests/generated/body-string/string.go b/test/src/tests/generated/body-string/string.go index ded0a9ae7..799757d28 100644 --- a/test/src/tests/generated/body-string/string.go +++ b/test/src/tests/generated/body-string/string.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewStringClientWithBaseURI(baseURI string) StringClient { // GetBase64Encoded get value that is base64 encoded func (client StringClient) GetBase64Encoded(ctx context.Context) (result Base64URL, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.GetBase64Encoded") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBase64EncodedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "GetBase64Encoded", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client StringClient) GetBase64EncodedResponder(resp *http.Response) (resul // GetBase64URLEncoded get value that is base64url encoded func (client StringClient) GetBase64URLEncoded(ctx context.Context) (result Base64URL, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.GetBase64URLEncoded") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBase64URLEncodedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "GetBase64URLEncoded", nil, "Failure preparing request") @@ -134,6 +155,16 @@ func (client StringClient) GetBase64URLEncodedResponder(resp *http.Response) (re // GetEmpty get empty string value value '' func (client StringClient) GetEmpty(ctx context.Context) (result StringModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.GetEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "GetEmpty", nil, "Failure preparing request") @@ -186,6 +217,16 @@ func (client StringClient) GetEmptyResponder(resp *http.Response) (result String // GetMbcs get mbcs string value '啊齄丂狛狜隣郎隣兀﨩ˊ〞〡￤℡㈱‐ー﹡﹢﹫、〓ⅰⅹ⒈€㈠㈩ⅠⅫ！￣ぁんァヶΑ︴АЯаяāɡㄅㄩ─╋︵﹄︻︱︳︴ⅰⅹɑɡ〇〾⿻⺁䜣€' func (client StringClient) GetMbcs(ctx context.Context) (result StringModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.GetMbcs") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetMbcsPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "GetMbcs", nil, "Failure preparing request") @@ -238,6 +279,16 @@ func (client StringClient) GetMbcsResponder(resp *http.Response) (result StringM // GetNotProvided get String value when no string value is sent in response payload func (client StringClient) GetNotProvided(ctx context.Context) (result StringModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.GetNotProvided") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNotProvidedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "GetNotProvided", nil, "Failure preparing request") @@ -290,6 +341,16 @@ func (client StringClient) GetNotProvidedResponder(resp *http.Response) (result // GetNull get null string value value func (client StringClient) GetNull(ctx context.Context) (result StringModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.GetNull") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "GetNull", nil, "Failure preparing request") @@ -342,6 +403,16 @@ func (client StringClient) GetNullResponder(resp *http.Response) (result StringM // GetNullBase64URLEncoded get null value that is expected to be base64url encoded func (client StringClient) GetNullBase64URLEncoded(ctx context.Context) (result Base64URL, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.GetNullBase64URLEncoded") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNullBase64URLEncodedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "GetNullBase64URLEncoded", nil, "Failure preparing request") @@ -395,6 +466,16 @@ func (client StringClient) GetNullBase64URLEncodedResponder(resp *http.Response) // GetWhitespace get string value with leading and trailing whitespace 'Now is the time for all good // men to come to the aid of their country' func (client StringClient) GetWhitespace(ctx context.Context) (result StringModel, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.GetWhitespace") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetWhitespacePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "GetWhitespace", nil, "Failure preparing request") @@ -447,6 +528,16 @@ func (client StringClient) GetWhitespaceResponder(resp *http.Response) (result S // PutBase64URLEncoded put value that is base64url encoded func (client StringClient) PutBase64URLEncoded(ctx context.Context, stringBody string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.PutBase64URLEncoded") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutBase64URLEncodedPreparer(ctx, stringBody) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "PutBase64URLEncoded", nil, "Failure preparing request") @@ -500,6 +591,16 @@ func (client StringClient) PutBase64URLEncodedResponder(resp *http.Response) (re // PutEmpty set string value empty '' func (client StringClient) PutEmpty(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.PutEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "PutEmpty", nil, "Failure preparing request") @@ -553,6 +654,16 @@ func (client StringClient) PutEmptyResponder(resp *http.Response) (result autore // PutMbcs set string value mbcs '啊齄丂狛狜隣郎隣兀﨩ˊ〞〡￤℡㈱‐ー﹡﹢﹫、〓ⅰⅹ⒈€㈠㈩ⅠⅫ！￣ぁんァヶΑ︴АЯаяāɡㄅㄩ─╋︵﹄︻︱︳︴ⅰⅹɑɡ〇〾⿻⺁䜣€' func (client StringClient) PutMbcs(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.PutMbcs") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutMbcsPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "PutMbcs", nil, "Failure preparing request") @@ -606,6 +717,16 @@ func (client StringClient) PutMbcsResponder(resp *http.Response) (result autores // PutNull set string value null func (client StringClient) PutNull(ctx context.Context, stringBody string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.PutNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutNullPreparer(ctx, stringBody) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "PutNull", nil, "Failure preparing request") @@ -663,6 +784,16 @@ func (client StringClient) PutNullResponder(resp *http.Response) (result autores // PutWhitespace set String value with leading and trailing whitespace 'Now is the time for all good // men to come to the aid of their country' func (client StringClient) PutWhitespace(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/StringClient.PutWhitespace") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutWhitespacePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "stringgroup.StringClient", "PutWhitespace", nil, "Failure preparing request") diff --git a/test/src/tests/generated/custom-baseurl/models.go b/test/src/tests/generated/custom-baseurl/models.go index c8ff1e60e..ff8a50e2d 100644 --- a/test/src/tests/generated/custom-baseurl/models.go +++ b/test/src/tests/generated/custom-baseurl/models.go @@ -6,6 +6,9 @@ package custombaseurlgroup // Code generated by Microsoft (R) AutoRest Code Generator. // Changes may cause incorrect behavior and will be lost if the code is regenerated. +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/custom-baseurl" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/custom-baseurl/paths.go b/test/src/tests/generated/custom-baseurl/paths.go index 82058999b..9c5f52b17 100644 --- a/test/src/tests/generated/custom-baseurl/paths.go +++ b/test/src/tests/generated/custom-baseurl/paths.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -27,6 +28,16 @@ func NewPathsClient() PathsClient { // Parameters: // accountName - account Name func (client PathsClient) GetEmpty(ctx context.Context, accountName string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.GetEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx, accountName) if err != nil { err = autorest.NewErrorWithError(err, "custombaseurlgroup.PathsClient", "GetEmpty", nil, "Failure preparing request") diff --git a/test/src/tests/generated/header/header.go b/test/src/tests/generated/header/header.go index 849dc607e..7f7afbf26 100644 --- a/test/src/tests/generated/header/header.go +++ b/test/src/tests/generated/header/header.go @@ -12,6 +12,7 @@ import ( "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -32,6 +33,16 @@ func NewHeaderClientWithBaseURI(baseURI string) HeaderClient { // CustomRequestID send x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 in the header of the request func (client HeaderClient) CustomRequestID(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.CustomRequestID") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.CustomRequestIDPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "CustomRequestID", nil, "Failure preparing request") @@ -87,6 +98,16 @@ func (client HeaderClient) CustomRequestIDResponder(resp *http.Response) (result // scenario - send a post request with header values "scenario": "true" or "false" // value - send a post request with header values true or false func (client HeaderClient) ParamBool(ctx context.Context, scenario string, value bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamBool") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamBoolPreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamBool", nil, "Failure preparing request") @@ -143,6 +164,16 @@ func (client HeaderClient) ParamBoolResponder(resp *http.Response) (result autor // scenario - send a post request with header values "scenario": "valid" // value - send a post request with header values "啊齄丂狛狜隣郎隣兀﨩" func (client HeaderClient) ParamByte(ctx context.Context, scenario string, value []byte) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamByte") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: value, Constraints: []validation.Constraint{{Target: "value", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -206,6 +237,16 @@ func (client HeaderClient) ParamByteResponder(resp *http.Response) (result autor // scenario - send a post request with header values "scenario": "valid" or "min" // value - send a post request with header values "2010-01-01" or "0001-01-01" func (client HeaderClient) ParamDate(ctx context.Context, scenario string, value date.Date) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamDate") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamDatePreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamDate", nil, "Failure preparing request") @@ -263,6 +304,16 @@ func (client HeaderClient) ParamDateResponder(resp *http.Response) (result autor // scenario - send a post request with header values "scenario": "valid" or "min" // value - send a post request with header values "2010-01-01T12:34:56Z" or "0001-01-01T00:00:00Z" func (client HeaderClient) ParamDatetime(ctx context.Context, scenario string, value date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamDatetime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamDatetimePreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamDatetime", nil, "Failure preparing request") @@ -321,6 +372,16 @@ func (client HeaderClient) ParamDatetimeResponder(resp *http.Response) (result a // value - send a post request with header values "Wed, 01 Jan 2010 12:34:56 GMT" or "Mon, 01 Jan 0001 00:00:00 // GMT" func (client HeaderClient) ParamDatetimeRfc1123(ctx context.Context, scenario string, value *date.TimeRFC1123) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamDatetimeRfc1123") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamDatetimeRfc1123Preparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamDatetimeRfc1123", nil, "Failure preparing request") @@ -381,6 +442,16 @@ func (client HeaderClient) ParamDatetimeRfc1123Responder(resp *http.Response) (r // scenario - send a post request with header values "scenario": "positive" or "negative" // value - send a post request with header values 7e120 or -3.0 func (client HeaderClient) ParamDouble(ctx context.Context, scenario string, value float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamDouble") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamDoublePreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamDouble", nil, "Failure preparing request") @@ -437,6 +508,16 @@ func (client HeaderClient) ParamDoubleResponder(resp *http.Response) (result aut // scenario - send a post request with header values "scenario": "valid" // value - send a post request with header values "P123DT22H14M12.011S" func (client HeaderClient) ParamDuration(ctx context.Context, scenario string, value string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamDuration") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamDurationPreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamDuration", nil, "Failure preparing request") @@ -494,6 +575,16 @@ func (client HeaderClient) ParamDurationResponder(resp *http.Response) (result a // scenario - send a post request with header values "scenario": "valid" or "null" or "empty" // value - send a post request with header values 'GREY' func (client HeaderClient) ParamEnum(ctx context.Context, scenario string, value GreyscaleColors) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamEnum") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamEnumPreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamEnum", nil, "Failure preparing request") @@ -552,6 +643,16 @@ func (client HeaderClient) ParamEnumResponder(resp *http.Response) (result autor // Parameters: // userAgent - send a post request with header value "User-Agent": "overwrite" func (client HeaderClient) ParamExistingKey(ctx context.Context, userAgent string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamExistingKey") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamExistingKeyPreparer(ctx, userAgent) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamExistingKey", nil, "Failure preparing request") @@ -608,6 +709,16 @@ func (client HeaderClient) ParamExistingKeyResponder(resp *http.Response) (resul // scenario - send a post request with header values "scenario": "positive" or "negative" // value - send a post request with header values 0.07 or -3.0 func (client HeaderClient) ParamFloat(ctx context.Context, scenario string, value float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamFloat") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamFloatPreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamFloat", nil, "Failure preparing request") @@ -665,6 +776,16 @@ func (client HeaderClient) ParamFloatResponder(resp *http.Response) (result auto // scenario - send a post request with header values "scenario": "positive" or "negative" // value - send a post request with header values 1 or -2 func (client HeaderClient) ParamInteger(ctx context.Context, scenario string, value int32) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamInteger") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamIntegerPreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamInteger", nil, "Failure preparing request") @@ -722,6 +843,16 @@ func (client HeaderClient) ParamIntegerResponder(resp *http.Response) (result au // scenario - send a post request with header values "scenario": "positive" or "negative" // value - send a post request with header values 105 or -2 func (client HeaderClient) ParamLong(ctx context.Context, scenario string, value int64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamLong") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamLongPreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamLong", nil, "Failure preparing request") @@ -777,6 +908,16 @@ func (client HeaderClient) ParamLongResponder(resp *http.Response) (result autor // Parameters: // contentType - send a post request with header value "Content-Type": "text/html" func (client HeaderClient) ParamProtectedKey(ctx context.Context, contentType string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamProtectedKey") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamProtectedKeyPreparer(ctx, contentType) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamProtectedKey", nil, "Failure preparing request") @@ -833,6 +974,16 @@ func (client HeaderClient) ParamProtectedKeyResponder(resp *http.Response) (resu // scenario - send a post request with header values "scenario": "valid" or "null" or "empty" // value - send a post request with header values "The quick brown fox jumps over the lazy dog" or null or "" func (client HeaderClient) ParamString(ctx context.Context, scenario string, value string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ParamString") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ParamStringPreparer(ctx, scenario, value) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ParamString", nil, "Failure preparing request") @@ -891,6 +1042,16 @@ func (client HeaderClient) ParamStringResponder(resp *http.Response) (result aut // Parameters: // scenario - send a post request with header values "scenario": "true" or "false" func (client HeaderClient) ResponseBool(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseBool") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseBoolPreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseBool", nil, "Failure preparing request") @@ -945,6 +1106,16 @@ func (client HeaderClient) ResponseBoolResponder(resp *http.Response) (result au // Parameters: // scenario - send a post request with header values "scenario": "valid" func (client HeaderClient) ResponseByte(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseByte") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseBytePreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseByte", nil, "Failure preparing request") @@ -999,6 +1170,16 @@ func (client HeaderClient) ResponseByteResponder(resp *http.Response) (result au // Parameters: // scenario - send a post request with header values "scenario": "valid" or "min" func (client HeaderClient) ResponseDate(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseDate") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseDatePreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseDate", nil, "Failure preparing request") @@ -1053,6 +1234,16 @@ func (client HeaderClient) ResponseDateResponder(resp *http.Response) (result au // Parameters: // scenario - send a post request with header values "scenario": "valid" or "min" func (client HeaderClient) ResponseDatetime(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseDatetime") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseDatetimePreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseDatetime", nil, "Failure preparing request") @@ -1108,6 +1299,16 @@ func (client HeaderClient) ResponseDatetimeResponder(resp *http.Response) (resul // Parameters: // scenario - send a post request with header values "scenario": "valid" or "min" func (client HeaderClient) ResponseDatetimeRfc1123(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseDatetimeRfc1123") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseDatetimeRfc1123Preparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseDatetimeRfc1123", nil, "Failure preparing request") @@ -1162,6 +1363,16 @@ func (client HeaderClient) ResponseDatetimeRfc1123Responder(resp *http.Response) // Parameters: // scenario - send a post request with header values "scenario": "positive" or "negative" func (client HeaderClient) ResponseDouble(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseDouble") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseDoublePreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseDouble", nil, "Failure preparing request") @@ -1216,6 +1427,16 @@ func (client HeaderClient) ResponseDoubleResponder(resp *http.Response) (result // Parameters: // scenario - send a post request with header values "scenario": "valid" func (client HeaderClient) ResponseDuration(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseDuration") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseDurationPreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseDuration", nil, "Failure preparing request") @@ -1270,6 +1491,16 @@ func (client HeaderClient) ResponseDurationResponder(resp *http.Response) (resul // Parameters: // scenario - send a post request with header values "scenario": "valid" or "null" or "empty" func (client HeaderClient) ResponseEnum(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseEnum") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseEnumPreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseEnum", nil, "Failure preparing request") @@ -1322,6 +1553,16 @@ func (client HeaderClient) ResponseEnumResponder(resp *http.Response) (result au // ResponseExistingKey get a response with header value "User-Agent": "overwrite" func (client HeaderClient) ResponseExistingKey(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseExistingKey") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseExistingKeyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseExistingKey", nil, "Failure preparing request") @@ -1375,6 +1616,16 @@ func (client HeaderClient) ResponseExistingKeyResponder(resp *http.Response) (re // Parameters: // scenario - send a post request with header values "scenario": "positive" or "negative" func (client HeaderClient) ResponseFloat(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseFloat") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseFloatPreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseFloat", nil, "Failure preparing request") @@ -1429,6 +1680,16 @@ func (client HeaderClient) ResponseFloatResponder(resp *http.Response) (result a // Parameters: // scenario - send a post request with header values "scenario": "positive" or "negative" func (client HeaderClient) ResponseInteger(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseInteger") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseIntegerPreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseInteger", nil, "Failure preparing request") @@ -1483,6 +1744,16 @@ func (client HeaderClient) ResponseIntegerResponder(resp *http.Response) (result // Parameters: // scenario - send a post request with header values "scenario": "positive" or "negative" func (client HeaderClient) ResponseLong(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseLong") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseLongPreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseLong", nil, "Failure preparing request") @@ -1535,6 +1806,16 @@ func (client HeaderClient) ResponseLongResponder(resp *http.Response) (result au // ResponseProtectedKey get a response with header value "Content-Type": "text/html" func (client HeaderClient) ResponseProtectedKey(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseProtectedKey") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseProtectedKeyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseProtectedKey", nil, "Failure preparing request") @@ -1588,6 +1869,16 @@ func (client HeaderClient) ResponseProtectedKeyResponder(resp *http.Response) (r // Parameters: // scenario - send a post request with header values "scenario": "valid" or "null" or "empty" func (client HeaderClient) ResponseString(ctx context.Context, scenario string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HeaderClient.ResponseString") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ResponseStringPreparer(ctx, scenario) if err != nil { err = autorest.NewErrorWithError(err, "headergroup.HeaderClient", "ResponseString", nil, "Failure preparing request") diff --git a/test/src/tests/generated/header/models.go b/test/src/tests/generated/header/models.go index cb0a115da..375be69ee 100644 --- a/test/src/tests/generated/header/models.go +++ b/test/src/tests/generated/header/models.go @@ -6,6 +6,9 @@ package headergroup // Code generated by Microsoft (R) AutoRest Code Generator. // Changes may cause incorrect behavior and will be lost if the code is regenerated. +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/header" + // GreyscaleColors enumerates the values for greyscale colors. type GreyscaleColors string diff --git a/test/src/tests/generated/httpinfrastructure/httpclientfailure.go b/test/src/tests/generated/httpinfrastructure/httpclientfailure.go index 0790617e2..ff41a3f96 100644 --- a/test/src/tests/generated/httpinfrastructure/httpclientfailure.go +++ b/test/src/tests/generated/httpinfrastructure/httpclientfailure.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -32,6 +33,16 @@ func NewHTTPClientFailureClientWithBaseURI(baseURI string) HTTPClientFailureClie // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Delete400(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Delete400") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete400Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Delete400", nil, "Failure preparing request") @@ -91,6 +102,16 @@ func (client HTTPClientFailureClient) Delete400Responder(resp *http.Response) (r // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Delete407(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Delete407") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete407Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Delete407", nil, "Failure preparing request") @@ -150,6 +171,16 @@ func (client HTTPClientFailureClient) Delete407Responder(resp *http.Response) (r // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Delete417(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Delete417") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete417Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Delete417", nil, "Failure preparing request") @@ -207,6 +238,16 @@ func (client HTTPClientFailureClient) Delete417Responder(resp *http.Response) (r // Get400 return 400 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Get400(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Get400") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get400Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Get400", nil, "Failure preparing request") @@ -259,6 +300,16 @@ func (client HTTPClientFailureClient) Get400Responder(resp *http.Response) (resu // Get402 return 402 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Get402(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Get402") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get402Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Get402", nil, "Failure preparing request") @@ -311,6 +362,16 @@ func (client HTTPClientFailureClient) Get402Responder(resp *http.Response) (resu // Get403 return 403 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Get403(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Get403") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get403Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Get403", nil, "Failure preparing request") @@ -363,6 +424,16 @@ func (client HTTPClientFailureClient) Get403Responder(resp *http.Response) (resu // Get411 return 411 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Get411(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Get411") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get411Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Get411", nil, "Failure preparing request") @@ -415,6 +486,16 @@ func (client HTTPClientFailureClient) Get411Responder(resp *http.Response) (resu // Get412 return 412 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Get412(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Get412") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get412Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Get412", nil, "Failure preparing request") @@ -467,6 +548,16 @@ func (client HTTPClientFailureClient) Get412Responder(resp *http.Response) (resu // Get416 return 416 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Get416(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Get416") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get416Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Get416", nil, "Failure preparing request") @@ -519,6 +610,16 @@ func (client HTTPClientFailureClient) Get416Responder(resp *http.Response) (resu // Head400 return 400 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Head400(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Head400") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head400Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Head400", nil, "Failure preparing request") @@ -571,6 +672,16 @@ func (client HTTPClientFailureClient) Head400Responder(resp *http.Response) (res // Head401 return 401 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Head401(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Head401") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head401Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Head401", nil, "Failure preparing request") @@ -623,6 +734,16 @@ func (client HTTPClientFailureClient) Head401Responder(resp *http.Response) (res // Head410 return 410 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Head410(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Head410") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head410Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Head410", nil, "Failure preparing request") @@ -675,6 +796,16 @@ func (client HTTPClientFailureClient) Head410Responder(resp *http.Response) (res // Head429 return 429 status code - should be represented in the client as an error func (client HTTPClientFailureClient) Head429(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Head429") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head429Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Head429", nil, "Failure preparing request") @@ -729,6 +860,16 @@ func (client HTTPClientFailureClient) Head429Responder(resp *http.Response) (res // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Patch400(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Patch400") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch400Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Patch400", nil, "Failure preparing request") @@ -788,6 +929,16 @@ func (client HTTPClientFailureClient) Patch400Responder(resp *http.Response) (re // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Patch405(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Patch405") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch405Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Patch405", nil, "Failure preparing request") @@ -847,6 +998,16 @@ func (client HTTPClientFailureClient) Patch405Responder(resp *http.Response) (re // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Patch414(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Patch414") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch414Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Patch414", nil, "Failure preparing request") @@ -906,6 +1067,16 @@ func (client HTTPClientFailureClient) Patch414Responder(resp *http.Response) (re // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Post400(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Post400") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post400Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Post400", nil, "Failure preparing request") @@ -965,6 +1136,16 @@ func (client HTTPClientFailureClient) Post400Responder(resp *http.Response) (res // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Post406(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Post406") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post406Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Post406", nil, "Failure preparing request") @@ -1024,6 +1205,16 @@ func (client HTTPClientFailureClient) Post406Responder(resp *http.Response) (res // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Post415(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Post415") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post415Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Post415", nil, "Failure preparing request") @@ -1083,6 +1274,16 @@ func (client HTTPClientFailureClient) Post415Responder(resp *http.Response) (res // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Put400(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Put400") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put400Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Put400", nil, "Failure preparing request") @@ -1142,6 +1343,16 @@ func (client HTTPClientFailureClient) Put400Responder(resp *http.Response) (resu // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Put404(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Put404") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put404Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Put404", nil, "Failure preparing request") @@ -1201,6 +1412,16 @@ func (client HTTPClientFailureClient) Put404Responder(resp *http.Response) (resu // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Put409(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Put409") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put409Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Put409", nil, "Failure preparing request") @@ -1260,6 +1481,16 @@ func (client HTTPClientFailureClient) Put409Responder(resp *http.Response) (resu // Parameters: // booleanValue - simple boolean value true func (client HTTPClientFailureClient) Put413(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPClientFailureClient.Put413") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put413Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPClientFailureClient", "Put413", nil, "Failure preparing request") diff --git a/test/src/tests/generated/httpinfrastructure/httpfailure.go b/test/src/tests/generated/httpinfrastructure/httpfailure.go index ffc1b66d8..3d573dca1 100644 --- a/test/src/tests/generated/httpinfrastructure/httpfailure.go +++ b/test/src/tests/generated/httpinfrastructure/httpfailure.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewHTTPFailureClientWithBaseURI(baseURI string) HTTPFailureClient { // GetEmptyError get empty error form server func (client HTTPFailureClient) GetEmptyError(ctx context.Context) (result Bool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPFailureClient.GetEmptyError") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyErrorPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPFailureClient", "GetEmptyError", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client HTTPFailureClient) GetEmptyErrorResponder(resp *http.Response) (res // GetNoModelEmpty get empty response from server func (client HTTPFailureClient) GetNoModelEmpty(ctx context.Context) (result Bool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPFailureClient.GetNoModelEmpty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNoModelEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPFailureClient", "GetNoModelEmpty", nil, "Failure preparing request") @@ -134,6 +155,16 @@ func (client HTTPFailureClient) GetNoModelEmptyResponder(resp *http.Response) (r // GetNoModelError get empty error form server func (client HTTPFailureClient) GetNoModelError(ctx context.Context) (result Bool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPFailureClient.GetNoModelError") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNoModelErrorPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPFailureClient", "GetNoModelError", nil, "Failure preparing request") diff --git a/test/src/tests/generated/httpinfrastructure/httpredirects.go b/test/src/tests/generated/httpinfrastructure/httpredirects.go index d9cdf7043..1da897137 100644 --- a/test/src/tests/generated/httpinfrastructure/httpredirects.go +++ b/test/src/tests/generated/httpinfrastructure/httpredirects.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -32,6 +33,16 @@ func NewHTTPRedirectsClientWithBaseURI(baseURI string) HTTPRedirectsClient { // Parameters: // booleanValue - simple boolean value true func (client HTTPRedirectsClient) Delete307(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Delete307") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete307Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Delete307", nil, "Failure preparing request") @@ -88,6 +99,16 @@ func (client HTTPRedirectsClient) Delete307Responder(resp *http.Response) (resul // Get300 return 300 status code and redirect to /http/success/200 func (client HTTPRedirectsClient) Get300(ctx context.Context) (result ListString, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Get300") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get300Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Get300", nil, "Failure preparing request") @@ -140,6 +161,16 @@ func (client HTTPRedirectsClient) Get300Responder(resp *http.Response) (result L // Get301 return 301 status code and redirect to /http/success/200 func (client HTTPRedirectsClient) Get301(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Get301") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get301Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Get301", nil, "Failure preparing request") @@ -191,6 +222,16 @@ func (client HTTPRedirectsClient) Get301Responder(resp *http.Response) (result a // Get302 return 302 status code and redirect to /http/success/200 func (client HTTPRedirectsClient) Get302(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Get302") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get302Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Get302", nil, "Failure preparing request") @@ -242,6 +283,16 @@ func (client HTTPRedirectsClient) Get302Responder(resp *http.Response) (result a // Get307 redirect get with 307, resulting in a 200 success func (client HTTPRedirectsClient) Get307(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Get307") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get307Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Get307", nil, "Failure preparing request") @@ -293,6 +344,16 @@ func (client HTTPRedirectsClient) Get307Responder(resp *http.Response) (result a // Head300 return 300 status code and redirect to /http/success/200 func (client HTTPRedirectsClient) Head300(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Head300") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head300Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Head300", nil, "Failure preparing request") @@ -344,6 +405,16 @@ func (client HTTPRedirectsClient) Head300Responder(resp *http.Response) (result // Head301 return 301 status code and redirect to /http/success/200 func (client HTTPRedirectsClient) Head301(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Head301") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head301Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Head301", nil, "Failure preparing request") @@ -395,6 +466,16 @@ func (client HTTPRedirectsClient) Head301Responder(resp *http.Response) (result // Head302 return 302 status code and redirect to /http/success/200 func (client HTTPRedirectsClient) Head302(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Head302") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head302Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Head302", nil, "Failure preparing request") @@ -446,6 +527,16 @@ func (client HTTPRedirectsClient) Head302Responder(resp *http.Response) (result // Head307 redirect with 307, resulting in a 200 success func (client HTTPRedirectsClient) Head307(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Head307") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head307Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Head307", nil, "Failure preparing request") @@ -500,6 +591,16 @@ func (client HTTPRedirectsClient) Head307Responder(resp *http.Response) (result // Parameters: // booleanValue - simple boolean value true func (client HTTPRedirectsClient) Patch302(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Patch302") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch302Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Patch302", nil, "Failure preparing request") @@ -558,6 +659,16 @@ func (client HTTPRedirectsClient) Patch302Responder(resp *http.Response) (result // Parameters: // booleanValue - simple boolean value true func (client HTTPRedirectsClient) Patch307(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Patch307") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch307Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Patch307", nil, "Failure preparing request") @@ -617,6 +728,16 @@ func (client HTTPRedirectsClient) Patch307Responder(resp *http.Response) (result // Parameters: // booleanValue - simple boolean value true func (client HTTPRedirectsClient) Post303(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Post303") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post303Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Post303", nil, "Failure preparing request") @@ -675,6 +796,16 @@ func (client HTTPRedirectsClient) Post303Responder(resp *http.Response) (result // Parameters: // booleanValue - simple boolean value true func (client HTTPRedirectsClient) Post307(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Post307") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post307Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Post307", nil, "Failure preparing request") @@ -734,6 +865,16 @@ func (client HTTPRedirectsClient) Post307Responder(resp *http.Response) (result // Parameters: // booleanValue - simple boolean value true func (client HTTPRedirectsClient) Put301(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Put301") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put301Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Put301", nil, "Failure preparing request") @@ -792,6 +933,16 @@ func (client HTTPRedirectsClient) Put301Responder(resp *http.Response) (result a // Parameters: // booleanValue - simple boolean value true func (client HTTPRedirectsClient) Put307(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRedirectsClient.Put307") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put307Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRedirectsClient", "Put307", nil, "Failure preparing request") diff --git a/test/src/tests/generated/httpinfrastructure/httpretry.go b/test/src/tests/generated/httpinfrastructure/httpretry.go index 484291545..50c529e8c 100644 --- a/test/src/tests/generated/httpinfrastructure/httpretry.go +++ b/test/src/tests/generated/httpinfrastructure/httpretry.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -32,6 +33,16 @@ func NewHTTPRetryClientWithBaseURI(baseURI string) HTTPRetryClient { // Parameters: // booleanValue - simple boolean value true func (client HTTPRetryClient) Delete503(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRetryClient.Delete503") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete503Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRetryClient", "Delete503", nil, "Failure preparing request") @@ -88,6 +99,16 @@ func (client HTTPRetryClient) Delete503Responder(resp *http.Response) (result au // Get502 return 502 status code, then 200 after retry func (client HTTPRetryClient) Get502(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRetryClient.Get502") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get502Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRetryClient", "Get502", nil, "Failure preparing request") @@ -139,6 +160,16 @@ func (client HTTPRetryClient) Get502Responder(resp *http.Response) (result autor // Head408 return 408 status code, then 200 after retry func (client HTTPRetryClient) Head408(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRetryClient.Head408") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head408Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRetryClient", "Head408", nil, "Failure preparing request") @@ -192,6 +223,16 @@ func (client HTTPRetryClient) Head408Responder(resp *http.Response) (result auto // Parameters: // booleanValue - simple boolean value true func (client HTTPRetryClient) Patch500(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRetryClient.Patch500") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch500Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRetryClient", "Patch500", nil, "Failure preparing request") @@ -250,6 +291,16 @@ func (client HTTPRetryClient) Patch500Responder(resp *http.Response) (result aut // Parameters: // booleanValue - simple boolean value true func (client HTTPRetryClient) Patch504(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRetryClient.Patch504") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch504Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRetryClient", "Patch504", nil, "Failure preparing request") @@ -308,6 +359,16 @@ func (client HTTPRetryClient) Patch504Responder(resp *http.Response) (result aut // Parameters: // booleanValue - simple boolean value true func (client HTTPRetryClient) Post503(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRetryClient.Post503") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post503Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRetryClient", "Post503", nil, "Failure preparing request") @@ -366,6 +427,16 @@ func (client HTTPRetryClient) Post503Responder(resp *http.Response) (result auto // Parameters: // booleanValue - simple boolean value true func (client HTTPRetryClient) Put500(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRetryClient.Put500") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put500Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRetryClient", "Put500", nil, "Failure preparing request") @@ -424,6 +495,16 @@ func (client HTTPRetryClient) Put500Responder(resp *http.Response) (result autor // Parameters: // booleanValue - simple boolean value true func (client HTTPRetryClient) Put504(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPRetryClient.Put504") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put504Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPRetryClient", "Put504", nil, "Failure preparing request") diff --git a/test/src/tests/generated/httpinfrastructure/httpserverfailure.go b/test/src/tests/generated/httpinfrastructure/httpserverfailure.go index c664b7533..f55f5e7fc 100644 --- a/test/src/tests/generated/httpinfrastructure/httpserverfailure.go +++ b/test/src/tests/generated/httpinfrastructure/httpserverfailure.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -32,6 +33,16 @@ func NewHTTPServerFailureClientWithBaseURI(baseURI string) HTTPServerFailureClie // Parameters: // booleanValue - simple boolean value true func (client HTTPServerFailureClient) Delete505(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPServerFailureClient.Delete505") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete505Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPServerFailureClient", "Delete505", nil, "Failure preparing request") @@ -89,6 +100,16 @@ func (client HTTPServerFailureClient) Delete505Responder(resp *http.Response) (r // Get501 return 501 status code - should be represented in the client as an error func (client HTTPServerFailureClient) Get501(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPServerFailureClient.Get501") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get501Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPServerFailureClient", "Get501", nil, "Failure preparing request") @@ -141,6 +162,16 @@ func (client HTTPServerFailureClient) Get501Responder(resp *http.Response) (resu // Head501 return 501 status code - should be represented in the client as an error func (client HTTPServerFailureClient) Head501(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPServerFailureClient.Head501") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head501Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPServerFailureClient", "Head501", nil, "Failure preparing request") @@ -195,6 +226,16 @@ func (client HTTPServerFailureClient) Head501Responder(resp *http.Response) (res // Parameters: // booleanValue - simple boolean value true func (client HTTPServerFailureClient) Post505(ctx context.Context, booleanValue *bool) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPServerFailureClient.Post505") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post505Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPServerFailureClient", "Post505", nil, "Failure preparing request") diff --git a/test/src/tests/generated/httpinfrastructure/httpsuccess.go b/test/src/tests/generated/httpinfrastructure/httpsuccess.go index 7b77ef347..315342de0 100644 --- a/test/src/tests/generated/httpinfrastructure/httpsuccess.go +++ b/test/src/tests/generated/httpinfrastructure/httpsuccess.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -32,6 +33,16 @@ func NewHTTPSuccessClientWithBaseURI(baseURI string) HTTPSuccessClient { // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Delete200(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Delete200") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete200Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Delete200", nil, "Failure preparing request") @@ -90,6 +101,16 @@ func (client HTTPSuccessClient) Delete200Responder(resp *http.Response) (result // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Delete202(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Delete202") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete202Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Delete202", nil, "Failure preparing request") @@ -148,6 +169,16 @@ func (client HTTPSuccessClient) Delete202Responder(resp *http.Response) (result // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Delete204(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Delete204") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete204Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Delete204", nil, "Failure preparing request") @@ -204,6 +235,16 @@ func (client HTTPSuccessClient) Delete204Responder(resp *http.Response) (result // Get200 get 200 success func (client HTTPSuccessClient) Get200(ctx context.Context) (result Bool, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Get200") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Get200", nil, "Failure preparing request") @@ -256,6 +297,16 @@ func (client HTTPSuccessClient) Get200Responder(resp *http.Response) (result Boo // Head200 return 200 status code if successful func (client HTTPSuccessClient) Head200(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Head200") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head200Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Head200", nil, "Failure preparing request") @@ -307,6 +358,16 @@ func (client HTTPSuccessClient) Head200Responder(resp *http.Response) (result au // Head204 return 204 status code if successful func (client HTTPSuccessClient) Head204(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Head204") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head204Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Head204", nil, "Failure preparing request") @@ -358,6 +419,16 @@ func (client HTTPSuccessClient) Head204Responder(resp *http.Response) (result au // Head404 return 404 status code func (client HTTPSuccessClient) Head404(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Head404") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Head404Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Head404", nil, "Failure preparing request") @@ -411,6 +482,16 @@ func (client HTTPSuccessClient) Head404Responder(resp *http.Response) (result au // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Patch200(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Patch200") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch200Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Patch200", nil, "Failure preparing request") @@ -469,6 +550,16 @@ func (client HTTPSuccessClient) Patch200Responder(resp *http.Response) (result a // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Patch202(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Patch202") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch202Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Patch202", nil, "Failure preparing request") @@ -527,6 +618,16 @@ func (client HTTPSuccessClient) Patch202Responder(resp *http.Response) (result a // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Patch204(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Patch204") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Patch204Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Patch204", nil, "Failure preparing request") @@ -585,6 +686,16 @@ func (client HTTPSuccessClient) Patch204Responder(resp *http.Response) (result a // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Post200(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Post200") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post200Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Post200", nil, "Failure preparing request") @@ -643,6 +754,16 @@ func (client HTTPSuccessClient) Post200Responder(resp *http.Response) (result au // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Post201(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Post201") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post201Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Post201", nil, "Failure preparing request") @@ -701,6 +822,16 @@ func (client HTTPSuccessClient) Post201Responder(resp *http.Response) (result au // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Post202(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Post202") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post202Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Post202", nil, "Failure preparing request") @@ -759,6 +890,16 @@ func (client HTTPSuccessClient) Post202Responder(resp *http.Response) (result au // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Post204(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Post204") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post204Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Post204", nil, "Failure preparing request") @@ -817,6 +958,16 @@ func (client HTTPSuccessClient) Post204Responder(resp *http.Response) (result au // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Put200(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Put200") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put200Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Put200", nil, "Failure preparing request") @@ -875,6 +1026,16 @@ func (client HTTPSuccessClient) Put200Responder(resp *http.Response) (result aut // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Put201(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Put201") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put201Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Put201", nil, "Failure preparing request") @@ -933,6 +1094,16 @@ func (client HTTPSuccessClient) Put201Responder(resp *http.Response) (result aut // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Put202(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Put202") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put202Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Put202", nil, "Failure preparing request") @@ -991,6 +1162,16 @@ func (client HTTPSuccessClient) Put202Responder(resp *http.Response) (result aut // Parameters: // booleanValue - simple boolean value true func (client HTTPSuccessClient) Put204(ctx context.Context, booleanValue *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HTTPSuccessClient.Put204") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put204Preparer(ctx, booleanValue) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.HTTPSuccessClient", "Put204", nil, "Failure preparing request") diff --git a/test/src/tests/generated/httpinfrastructure/models.go b/test/src/tests/generated/httpinfrastructure/models.go index 0c12c156d..15151cd4b 100644 --- a/test/src/tests/generated/httpinfrastructure/models.go +++ b/test/src/tests/generated/httpinfrastructure/models.go @@ -10,6 +10,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/httpinfrastructure" + // A ... type A struct { autorest.Response `json:"-"` diff --git a/test/src/tests/generated/httpinfrastructure/multipleresponses.go b/test/src/tests/generated/httpinfrastructure/multipleresponses.go index 523aa821a..06020547a 100644 --- a/test/src/tests/generated/httpinfrastructure/multipleresponses.go +++ b/test/src/tests/generated/httpinfrastructure/multipleresponses.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewMultipleResponsesClientWithBaseURI(baseURI string) MultipleResponsesClie // Get200Model201ModelDefaultError200Valid send a 200 response with valid payload: {'statusCode': '200'} func (client MultipleResponsesClient) Get200Model201ModelDefaultError200Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200Model201ModelDefaultError200Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Model201ModelDefaultError200ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200Model201ModelDefaultError200Valid", nil, "Failure preparing request") @@ -83,6 +94,16 @@ func (client MultipleResponsesClient) Get200Model201ModelDefaultError200ValidRes // Get200Model201ModelDefaultError201Valid send a 201 response with valid payload: {'statusCode': '201', // 'textStatusCode': 'Created'} func (client MultipleResponsesClient) Get200Model201ModelDefaultError201Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200Model201ModelDefaultError201Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Model201ModelDefaultError201ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200Model201ModelDefaultError201Valid", nil, "Failure preparing request") @@ -136,6 +157,16 @@ func (client MultipleResponsesClient) Get200Model201ModelDefaultError201ValidRes // Get200Model201ModelDefaultError400Valid send a 400 response with valid payload: {'code': '400', 'message': 'client // error'} func (client MultipleResponsesClient) Get200Model201ModelDefaultError400Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200Model201ModelDefaultError400Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Model201ModelDefaultError400ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200Model201ModelDefaultError400Valid", nil, "Failure preparing request") @@ -188,6 +219,16 @@ func (client MultipleResponsesClient) Get200Model201ModelDefaultError400ValidRes // Get200Model204NoModelDefaultError200Valid send a 200 response with valid payload: {'statusCode': '200'} func (client MultipleResponsesClient) Get200Model204NoModelDefaultError200Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200Model204NoModelDefaultError200Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Model204NoModelDefaultError200ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200Model204NoModelDefaultError200Valid", nil, "Failure preparing request") @@ -240,6 +281,16 @@ func (client MultipleResponsesClient) Get200Model204NoModelDefaultError200ValidR // Get200Model204NoModelDefaultError201Invalid send a 201 response with valid payload: {'statusCode': '201'} func (client MultipleResponsesClient) Get200Model204NoModelDefaultError201Invalid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200Model204NoModelDefaultError201Invalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Model204NoModelDefaultError201InvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200Model204NoModelDefaultError201Invalid", nil, "Failure preparing request") @@ -292,6 +343,16 @@ func (client MultipleResponsesClient) Get200Model204NoModelDefaultError201Invali // Get200Model204NoModelDefaultError202None send a 202 response with no payload: func (client MultipleResponsesClient) Get200Model204NoModelDefaultError202None(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200Model204NoModelDefaultError202None") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Model204NoModelDefaultError202NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200Model204NoModelDefaultError202None", nil, "Failure preparing request") @@ -344,6 +405,16 @@ func (client MultipleResponsesClient) Get200Model204NoModelDefaultError202NoneRe // Get200Model204NoModelDefaultError204Valid send a 204 response with no payload func (client MultipleResponsesClient) Get200Model204NoModelDefaultError204Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200Model204NoModelDefaultError204Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Model204NoModelDefaultError204ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200Model204NoModelDefaultError204Valid", nil, "Failure preparing request") @@ -397,6 +468,16 @@ func (client MultipleResponsesClient) Get200Model204NoModelDefaultError204ValidR // Get200Model204NoModelDefaultError400Valid send a 400 response with valid error payload: {'status': 400, 'message': // 'client error'} func (client MultipleResponsesClient) Get200Model204NoModelDefaultError400Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200Model204NoModelDefaultError400Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200Model204NoModelDefaultError400ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200Model204NoModelDefaultError400Valid", nil, "Failure preparing request") @@ -449,6 +530,16 @@ func (client MultipleResponsesClient) Get200Model204NoModelDefaultError400ValidR // Get200ModelA200Invalid send a 200 response with invalid payload {'statusCodeInvalid': '200'} func (client MultipleResponsesClient) Get200ModelA200Invalid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA200Invalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA200InvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA200Invalid", nil, "Failure preparing request") @@ -502,6 +593,16 @@ func (client MultipleResponsesClient) Get200ModelA200InvalidResponder(resp *http // Get200ModelA200None send a 200 response with no payload, when a payload is expected - client should return a null // object of thde type for model A func (client MultipleResponsesClient) Get200ModelA200None(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA200None") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA200NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA200None", nil, "Failure preparing request") @@ -554,6 +655,16 @@ func (client MultipleResponsesClient) Get200ModelA200NoneResponder(resp *http.Re // Get200ModelA200Valid send a 200 response with payload {'statusCode': '200'} func (client MultipleResponsesClient) Get200ModelA200Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA200Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA200ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA200Valid", nil, "Failure preparing request") @@ -606,6 +717,16 @@ func (client MultipleResponsesClient) Get200ModelA200ValidResponder(resp *http.R // Get200ModelA201ModelC404ModelDDefaultError200Valid send a 200 response with valid payload: {'statusCode': '200'} func (client MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError200Valid(ctx context.Context) (result SetObject, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA201ModelC404ModelDDefaultError200Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA201ModelC404ModelDDefaultError200ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA201ModelC404ModelDDefaultError200Valid", nil, "Failure preparing request") @@ -658,6 +779,16 @@ func (client MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError // Get200ModelA201ModelC404ModelDDefaultError201Valid send a 200 response with valid payload: {'httpCode': '201'} func (client MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError201Valid(ctx context.Context) (result SetObject, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA201ModelC404ModelDDefaultError201Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA201ModelC404ModelDDefaultError201ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA201ModelC404ModelDDefaultError201Valid", nil, "Failure preparing request") @@ -711,6 +842,16 @@ func (client MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError // Get200ModelA201ModelC404ModelDDefaultError400Valid send a 400 response with valid payload: {'code': '400', // 'message': 'client error'} func (client MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError400Valid(ctx context.Context) (result SetObject, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA201ModelC404ModelDDefaultError400Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA201ModelC404ModelDDefaultError400ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA201ModelC404ModelDDefaultError400Valid", nil, "Failure preparing request") @@ -763,6 +904,16 @@ func (client MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError // Get200ModelA201ModelC404ModelDDefaultError404Valid send a 200 response with valid payload: {'httpStatusCode': '404'} func (client MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError404Valid(ctx context.Context) (result SetObject, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA201ModelC404ModelDDefaultError404Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA201ModelC404ModelDDefaultError404ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA201ModelC404ModelDDefaultError404Valid", nil, "Failure preparing request") @@ -815,6 +966,16 @@ func (client MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError // Get200ModelA202Valid send a 202 response with payload {'statusCode': '202'} func (client MultipleResponsesClient) Get200ModelA202Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA202Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA202ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA202Valid", nil, "Failure preparing request") @@ -867,6 +1028,16 @@ func (client MultipleResponsesClient) Get200ModelA202ValidResponder(resp *http.R // Get200ModelA400Invalid send a 200 response with invalid payload {'statusCodeInvalid': '400'} func (client MultipleResponsesClient) Get200ModelA400Invalid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA400Invalid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA400InvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA400Invalid", nil, "Failure preparing request") @@ -919,6 +1090,16 @@ func (client MultipleResponsesClient) Get200ModelA400InvalidResponder(resp *http // Get200ModelA400None send a 400 response with no payload client should treat as an http error with no error model func (client MultipleResponsesClient) Get200ModelA400None(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA400None") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA400NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA400None", nil, "Failure preparing request") @@ -971,6 +1152,16 @@ func (client MultipleResponsesClient) Get200ModelA400NoneResponder(resp *http.Re // Get200ModelA400Valid send a 200 response with payload {'statusCode': '400'} func (client MultipleResponsesClient) Get200ModelA400Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get200ModelA400Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get200ModelA400ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get200ModelA400Valid", nil, "Failure preparing request") @@ -1023,6 +1214,16 @@ func (client MultipleResponsesClient) Get200ModelA400ValidResponder(resp *http.R // Get202None204NoneDefaultError202None send a 202 response with no payload func (client MultipleResponsesClient) Get202None204NoneDefaultError202None(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get202None204NoneDefaultError202None") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get202None204NoneDefaultError202NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get202None204NoneDefaultError202None", nil, "Failure preparing request") @@ -1074,6 +1275,16 @@ func (client MultipleResponsesClient) Get202None204NoneDefaultError202NoneRespon // Get202None204NoneDefaultError204None send a 204 response with no payload func (client MultipleResponsesClient) Get202None204NoneDefaultError204None(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get202None204NoneDefaultError204None") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get202None204NoneDefaultError204NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get202None204NoneDefaultError204None", nil, "Failure preparing request") @@ -1126,6 +1337,16 @@ func (client MultipleResponsesClient) Get202None204NoneDefaultError204NoneRespon // Get202None204NoneDefaultError400Valid send a 400 response with valid payload: {'code': '400', 'message': 'client // error'} func (client MultipleResponsesClient) Get202None204NoneDefaultError400Valid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get202None204NoneDefaultError400Valid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get202None204NoneDefaultError400ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get202None204NoneDefaultError400Valid", nil, "Failure preparing request") @@ -1177,6 +1398,16 @@ func (client MultipleResponsesClient) Get202None204NoneDefaultError400ValidRespo // Get202None204NoneDefaultNone202Invalid send a 202 response with an unexpected payload {'property': 'value'} func (client MultipleResponsesClient) Get202None204NoneDefaultNone202Invalid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get202None204NoneDefaultNone202Invalid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get202None204NoneDefaultNone202InvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get202None204NoneDefaultNone202Invalid", nil, "Failure preparing request") @@ -1228,6 +1459,16 @@ func (client MultipleResponsesClient) Get202None204NoneDefaultNone202InvalidResp // Get202None204NoneDefaultNone204None send a 204 response with no payload func (client MultipleResponsesClient) Get202None204NoneDefaultNone204None(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get202None204NoneDefaultNone204None") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get202None204NoneDefaultNone204NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get202None204NoneDefaultNone204None", nil, "Failure preparing request") @@ -1279,6 +1520,16 @@ func (client MultipleResponsesClient) Get202None204NoneDefaultNone204NoneRespond // Get202None204NoneDefaultNone400Invalid send a 400 response with an unexpected payload {'property': 'value'} func (client MultipleResponsesClient) Get202None204NoneDefaultNone400Invalid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get202None204NoneDefaultNone400Invalid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get202None204NoneDefaultNone400InvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get202None204NoneDefaultNone400Invalid", nil, "Failure preparing request") @@ -1330,6 +1581,16 @@ func (client MultipleResponsesClient) Get202None204NoneDefaultNone400InvalidResp // Get202None204NoneDefaultNone400None send a 400 response with no payload func (client MultipleResponsesClient) Get202None204NoneDefaultNone400None(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.Get202None204NoneDefaultNone400None") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Get202None204NoneDefaultNone400NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "Get202None204NoneDefaultNone400None", nil, "Failure preparing request") @@ -1381,6 +1642,16 @@ func (client MultipleResponsesClient) Get202None204NoneDefaultNone400NoneRespond // GetDefaultModelA200None send a 200 response with no payload func (client MultipleResponsesClient) GetDefaultModelA200None(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.GetDefaultModelA200None") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDefaultModelA200NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "GetDefaultModelA200None", nil, "Failure preparing request") @@ -1433,6 +1704,16 @@ func (client MultipleResponsesClient) GetDefaultModelA200NoneResponder(resp *htt // GetDefaultModelA200Valid send a 200 response with valid payload: {'statusCode': '200'} func (client MultipleResponsesClient) GetDefaultModelA200Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.GetDefaultModelA200Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDefaultModelA200ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "GetDefaultModelA200Valid", nil, "Failure preparing request") @@ -1485,6 +1766,16 @@ func (client MultipleResponsesClient) GetDefaultModelA200ValidResponder(resp *ht // GetDefaultModelA400None send a 400 response with no payload func (client MultipleResponsesClient) GetDefaultModelA400None(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.GetDefaultModelA400None") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDefaultModelA400NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "GetDefaultModelA400None", nil, "Failure preparing request") @@ -1537,6 +1828,16 @@ func (client MultipleResponsesClient) GetDefaultModelA400NoneResponder(resp *htt // GetDefaultModelA400Valid send a 400 response with valid payload: {'statusCode': '400'} func (client MultipleResponsesClient) GetDefaultModelA400Valid(ctx context.Context) (result A, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.GetDefaultModelA400Valid") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDefaultModelA400ValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "GetDefaultModelA400Valid", nil, "Failure preparing request") @@ -1589,6 +1890,16 @@ func (client MultipleResponsesClient) GetDefaultModelA400ValidResponder(resp *ht // GetDefaultNone200Invalid send a 200 response with invalid payload: {'statusCode': '200'} func (client MultipleResponsesClient) GetDefaultNone200Invalid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.GetDefaultNone200Invalid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDefaultNone200InvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "GetDefaultNone200Invalid", nil, "Failure preparing request") @@ -1640,6 +1951,16 @@ func (client MultipleResponsesClient) GetDefaultNone200InvalidResponder(resp *ht // GetDefaultNone200None send a 200 response with no payload func (client MultipleResponsesClient) GetDefaultNone200None(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.GetDefaultNone200None") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDefaultNone200NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "GetDefaultNone200None", nil, "Failure preparing request") @@ -1691,6 +2012,16 @@ func (client MultipleResponsesClient) GetDefaultNone200NoneResponder(resp *http. // GetDefaultNone400Invalid send a 400 response with valid payload: {'statusCode': '400'} func (client MultipleResponsesClient) GetDefaultNone400Invalid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.GetDefaultNone400Invalid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDefaultNone400InvalidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "GetDefaultNone400Invalid", nil, "Failure preparing request") @@ -1742,6 +2073,16 @@ func (client MultipleResponsesClient) GetDefaultNone400InvalidResponder(resp *ht // GetDefaultNone400None send a 400 response with no payload func (client MultipleResponsesClient) GetDefaultNone400None(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/MultipleResponsesClient.GetDefaultNone400None") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDefaultNone400NonePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "httpinfrastructuregroup.MultipleResponsesClient", "GetDefaultNone400None", nil, "Failure preparing request") diff --git a/test/src/tests/generated/lro/lroretrys.go b/test/src/tests/generated/lro/lroretrys.go index 158e02b57..efa0b4ee5 100644 --- a/test/src/tests/generated/lro/lroretrys.go +++ b/test/src/tests/generated/lro/lroretrys.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewLRORetrysClientWithBaseURI(baseURI string) LRORetrysClient { // Delete202Retry200 long running delete request, service returns a 500, then a 202 to the initial request. Polls // return this value until the last poll returns a ‘200’ with ProvisioningState=’Succeeded’ func (client LRORetrysClient) Delete202Retry200(ctx context.Context) (result LRORetrysDelete202Retry200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LRORetrysClient.Delete202Retry200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete202Retry200Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LRORetrysClient", "Delete202Retry200", nil, "Failure preparing request") @@ -83,6 +94,16 @@ func (client LRORetrysClient) Delete202Retry200Responder(resp *http.Response) (r // DeleteAsyncRelativeRetrySucceeded long running delete request, service returns a 500, then a 202 to the initial // request. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status func (client LRORetrysClient) DeleteAsyncRelativeRetrySucceeded(ctx context.Context) (result LRORetrysDeleteAsyncRelativeRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LRORetrysClient.DeleteAsyncRelativeRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncRelativeRetrySucceededPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LRORetrysClient", "DeleteAsyncRelativeRetrySucceeded", nil, "Failure preparing request") @@ -136,6 +157,16 @@ func (client LRORetrysClient) DeleteAsyncRelativeRetrySucceededResponder(resp *h // initial request, with an entity that contains ProvisioningState=’Accepted’. Polls return this value until the last // poll returns a ‘200’ with ProvisioningState=’Succeeded’ func (client LRORetrysClient) DeleteProvisioning202Accepted200Succeeded(ctx context.Context) (result LRORetrysDeleteProvisioning202Accepted200SucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LRORetrysClient.DeleteProvisioning202Accepted200Succeeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteProvisioning202Accepted200SucceededPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LRORetrysClient", "DeleteProvisioning202Accepted200Succeeded", nil, "Failure preparing request") @@ -191,6 +222,16 @@ func (client LRORetrysClient) DeleteProvisioning202Accepted200SucceededResponder // Parameters: // product - product to put func (client LRORetrysClient) Post202Retry200(ctx context.Context, product *Product) (result LRORetrysPost202Retry200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LRORetrysClient.Post202Retry200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post202Retry200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LRORetrysClient", "Post202Retry200", nil, "Failure preparing request") @@ -251,6 +292,16 @@ func (client LRORetrysClient) Post202Retry200Responder(resp *http.Response) (res // Parameters: // product - product to put func (client LRORetrysClient) PostAsyncRelativeRetrySucceeded(ctx context.Context, product *Product) (result LRORetrysPostAsyncRelativeRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LRORetrysClient.PostAsyncRelativeRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRelativeRetrySucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LRORetrysClient", "PostAsyncRelativeRetrySucceeded", nil, "Failure preparing request") @@ -311,6 +362,16 @@ func (client LRORetrysClient) PostAsyncRelativeRetrySucceededResponder(resp *htt // Parameters: // product - product to put func (client LRORetrysClient) Put201CreatingSucceeded200(ctx context.Context, product *Product) (result LRORetrysPut201CreatingSucceeded200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LRORetrysClient.Put201CreatingSucceeded200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put201CreatingSucceeded200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LRORetrysClient", "Put201CreatingSucceeded200", nil, "Failure preparing request") @@ -372,6 +433,16 @@ func (client LRORetrysClient) Put201CreatingSucceeded200Responder(resp *http.Res // Parameters: // product - product to put func (client LRORetrysClient) PutAsyncRelativeRetrySucceeded(ctx context.Context, product *Product) (result LRORetrysPutAsyncRelativeRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LRORetrysClient.PutAsyncRelativeRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRelativeRetrySucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LRORetrysClient", "PutAsyncRelativeRetrySucceeded", nil, "Failure preparing request") diff --git a/test/src/tests/generated/lro/lros.go b/test/src/tests/generated/lro/lros.go index c680907a4..505c746df 100644 --- a/test/src/tests/generated/lro/lros.go +++ b/test/src/tests/generated/lro/lros.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewLROsClientWithBaseURI(baseURI string) LROsClient { // Delete202NoRetry204 long running delete request, service returns a 202 to the initial request. Polls return this // value until the last poll returns a ‘200’ with ProvisioningState=’Succeeded’ func (client LROsClient) Delete202NoRetry204(ctx context.Context) (result LROsDelete202NoRetry204Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Delete202NoRetry204") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete202NoRetry204Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Delete202NoRetry204", nil, "Failure preparing request") @@ -84,6 +95,16 @@ func (client LROsClient) Delete202NoRetry204Responder(resp *http.Response) (resu // Delete202Retry200 long running delete request, service returns a 202 to the initial request. Polls return this value // until the last poll returns a ‘200’ with ProvisioningState=’Succeeded’ func (client LROsClient) Delete202Retry200(ctx context.Context) (result LROsDelete202Retry200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Delete202Retry200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete202Retry200Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Delete202Retry200", nil, "Failure preparing request") @@ -136,6 +157,16 @@ func (client LROsClient) Delete202Retry200Responder(resp *http.Response) (result // Delete204Succeeded long running delete succeeds and returns right away func (client LROsClient) Delete204Succeeded(ctx context.Context) (result LROsDelete204SucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Delete204Succeeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete204SucceededPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Delete204Succeeded", nil, "Failure preparing request") @@ -188,6 +219,16 @@ func (client LROsClient) Delete204SucceededResponder(resp *http.Response) (resul // DeleteAsyncNoHeaderInRetry long running delete request, service returns an Azure-AsyncOperation header in the // initial request. Subsequent calls to operation status do not contain Azure-AsyncOperation header. func (client LROsClient) DeleteAsyncNoHeaderInRetry(ctx context.Context) (result LROsDeleteAsyncNoHeaderInRetryFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteAsyncNoHeaderInRetry") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncNoHeaderInRetryPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteAsyncNoHeaderInRetry", nil, "Failure preparing request") @@ -240,6 +281,16 @@ func (client LROsClient) DeleteAsyncNoHeaderInRetryResponder(resp *http.Response // DeleteAsyncNoRetrySucceeded long running delete request, service returns a 202 to the initial request. Poll the // endpoint indicated in the Azure-AsyncOperation header for operation status func (client LROsClient) DeleteAsyncNoRetrySucceeded(ctx context.Context) (result LROsDeleteAsyncNoRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteAsyncNoRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncNoRetrySucceededPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteAsyncNoRetrySucceeded", nil, "Failure preparing request") @@ -292,6 +343,16 @@ func (client LROsClient) DeleteAsyncNoRetrySucceededResponder(resp *http.Respons // DeleteAsyncRetrycanceled long running delete request, service returns a 202 to the initial request. Poll the // endpoint indicated in the Azure-AsyncOperation header for operation status func (client LROsClient) DeleteAsyncRetrycanceled(ctx context.Context) (result LROsDeleteAsyncRetrycanceledFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteAsyncRetrycanceled") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncRetrycanceledPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteAsyncRetrycanceled", nil, "Failure preparing request") @@ -344,6 +405,16 @@ func (client LROsClient) DeleteAsyncRetrycanceledResponder(resp *http.Response) // DeleteAsyncRetryFailed long running delete request, service returns a 202 to the initial request. Poll the endpoint // indicated in the Azure-AsyncOperation header for operation status func (client LROsClient) DeleteAsyncRetryFailed(ctx context.Context) (result LROsDeleteAsyncRetryFailedFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteAsyncRetryFailed") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncRetryFailedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteAsyncRetryFailed", nil, "Failure preparing request") @@ -396,6 +467,16 @@ func (client LROsClient) DeleteAsyncRetryFailedResponder(resp *http.Response) (r // DeleteAsyncRetrySucceeded long running delete request, service returns a 202 to the initial request. Poll the // endpoint indicated in the Azure-AsyncOperation header for operation status func (client LROsClient) DeleteAsyncRetrySucceeded(ctx context.Context) (result LROsDeleteAsyncRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteAsyncRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncRetrySucceededPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteAsyncRetrySucceeded", nil, "Failure preparing request") @@ -448,6 +529,16 @@ func (client LROsClient) DeleteAsyncRetrySucceededResponder(resp *http.Response) // DeleteNoHeaderInRetry long running delete request, service returns a location header in the initial request. // Subsequent calls to operation status do not contain location header. func (client LROsClient) DeleteNoHeaderInRetry(ctx context.Context) (result LROsDeleteNoHeaderInRetryFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteNoHeaderInRetry") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteNoHeaderInRetryPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteNoHeaderInRetry", nil, "Failure preparing request") @@ -501,6 +592,16 @@ func (client LROsClient) DeleteNoHeaderInRetryResponder(resp *http.Response) (re // with an entity that contains ProvisioningState=’Accepted’. Polls return this value until the last poll returns a // ‘200’ with ProvisioningState=’Succeeded’ func (client LROsClient) DeleteProvisioning202Accepted200Succeeded(ctx context.Context) (result LROsDeleteProvisioning202Accepted200SucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteProvisioning202Accepted200Succeeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteProvisioning202Accepted200SucceededPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteProvisioning202Accepted200Succeeded", nil, "Failure preparing request") @@ -555,6 +656,16 @@ func (client LROsClient) DeleteProvisioning202Accepted200SucceededResponder(resp // with an entity that contains ProvisioningState=’Creating’. Polls return this value until the last poll returns a // ‘200’ with ProvisioningState=’Canceled’ func (client LROsClient) DeleteProvisioning202Deletingcanceled200(ctx context.Context) (result LROsDeleteProvisioning202Deletingcanceled200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteProvisioning202Deletingcanceled200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteProvisioning202Deletingcanceled200Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteProvisioning202Deletingcanceled200", nil, "Failure preparing request") @@ -609,6 +720,16 @@ func (client LROsClient) DeleteProvisioning202Deletingcanceled200Responder(resp // with an entity that contains ProvisioningState=’Creating’. Polls return this value until the last poll returns a // ‘200’ with ProvisioningState=’Failed’ func (client LROsClient) DeleteProvisioning202DeletingFailed200(ctx context.Context) (result LROsDeleteProvisioning202DeletingFailed200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.DeleteProvisioning202DeletingFailed200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteProvisioning202DeletingFailed200Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "DeleteProvisioning202DeletingFailed200", nil, "Failure preparing request") @@ -662,6 +783,16 @@ func (client LROsClient) DeleteProvisioning202DeletingFailed200Responder(resp *h // Post200WithPayload long running post request, service returns a 202 to the initial request, with 'Location' header. // Poll returns a 200 with a response body after success. func (client LROsClient) Post200WithPayload(ctx context.Context) (result LROsPost200WithPayloadFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Post200WithPayload") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post200WithPayloadPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Post200WithPayload", nil, "Failure preparing request") @@ -717,6 +848,16 @@ func (client LROsClient) Post200WithPayloadResponder(resp *http.Response) (resul // Parameters: // product - product to put func (client LROsClient) Post202NoRetry204(ctx context.Context, product *Product) (result LROsPost202NoRetry204Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Post202NoRetry204") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post202NoRetry204Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Post202NoRetry204", nil, "Failure preparing request") @@ -777,6 +918,16 @@ func (client LROsClient) Post202NoRetry204Responder(resp *http.Response) (result // Parameters: // product - product to put func (client LROsClient) Post202Retry200(ctx context.Context, product *Product) (result LROsPost202Retry200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Post202Retry200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post202Retry200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Post202Retry200", nil, "Failure preparing request") @@ -837,6 +988,16 @@ func (client LROsClient) Post202Retry200Responder(resp *http.Response) (result a // Parameters: // product - product to put func (client LROsClient) PostAsyncNoRetrySucceeded(ctx context.Context, product *Product) (result LROsPostAsyncNoRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PostAsyncNoRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncNoRetrySucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PostAsyncNoRetrySucceeded", nil, "Failure preparing request") @@ -898,6 +1059,16 @@ func (client LROsClient) PostAsyncNoRetrySucceededResponder(resp *http.Response) // Parameters: // product - product to put func (client LROsClient) PostAsyncRetrycanceled(ctx context.Context, product *Product) (result LROsPostAsyncRetrycanceledFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PostAsyncRetrycanceled") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRetrycanceledPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PostAsyncRetrycanceled", nil, "Failure preparing request") @@ -958,6 +1129,16 @@ func (client LROsClient) PostAsyncRetrycanceledResponder(resp *http.Response) (r // Parameters: // product - product to put func (client LROsClient) PostAsyncRetryFailed(ctx context.Context, product *Product) (result LROsPostAsyncRetryFailedFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PostAsyncRetryFailed") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRetryFailedPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PostAsyncRetryFailed", nil, "Failure preparing request") @@ -1018,6 +1199,16 @@ func (client LROsClient) PostAsyncRetryFailedResponder(resp *http.Response) (res // Parameters: // product - product to put func (client LROsClient) PostAsyncRetrySucceeded(ctx context.Context, product *Product) (result LROsPostAsyncRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PostAsyncRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRetrySucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PostAsyncRetrySucceeded", nil, "Failure preparing request") @@ -1077,6 +1268,16 @@ func (client LROsClient) PostAsyncRetrySucceededResponder(resp *http.Response) ( // both Location and Azure-Async header. Poll Azure-Async and it's success. Should NOT poll Location to get the final // object func (client LROsClient) PostDoubleHeadersFinalAzureHeaderGet(ctx context.Context) (result LROsPostDoubleHeadersFinalAzureHeaderGetFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PostDoubleHeadersFinalAzureHeaderGet") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostDoubleHeadersFinalAzureHeaderGetPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PostDoubleHeadersFinalAzureHeaderGet", nil, "Failure preparing request") @@ -1131,6 +1332,16 @@ func (client LROsClient) PostDoubleHeadersFinalAzureHeaderGetResponder(resp *htt // with both Location and Azure-Async header. Poll Azure-Async and it's success. Should NOT poll Location to get the // final object if you support initial Autorest behavior. func (client LROsClient) PostDoubleHeadersFinalAzureHeaderGetDefault(ctx context.Context) (result LROsPostDoubleHeadersFinalAzureHeaderGetDefaultFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PostDoubleHeadersFinalAzureHeaderGetDefault") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostDoubleHeadersFinalAzureHeaderGetDefaultPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PostDoubleHeadersFinalAzureHeaderGetDefault", nil, "Failure preparing request") @@ -1184,6 +1395,16 @@ func (client LROsClient) PostDoubleHeadersFinalAzureHeaderGetDefaultResponder(re // PostDoubleHeadersFinalLocationGet long running post request, service returns a 202 to the initial request with both // Location and Azure-Async header. Poll Azure-Async and it's success. Should poll Location to get the final object func (client LROsClient) PostDoubleHeadersFinalLocationGet(ctx context.Context) (result LROsPostDoubleHeadersFinalLocationGetFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PostDoubleHeadersFinalLocationGet") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostDoubleHeadersFinalLocationGetPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PostDoubleHeadersFinalLocationGet", nil, "Failure preparing request") @@ -1240,6 +1461,16 @@ func (client LROsClient) PostDoubleHeadersFinalLocationGetResponder(resp *http.R // Parameters: // product - product to put func (client LROsClient) Put200Acceptedcanceled200(ctx context.Context, product *Product) (result LROsPut200Acceptedcanceled200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Put200Acceptedcanceled200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put200Acceptedcanceled200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Put200Acceptedcanceled200", nil, "Failure preparing request") @@ -1300,6 +1531,16 @@ func (client LROsClient) Put200Acceptedcanceled200Responder(resp *http.Response) // Parameters: // product - product to put func (client LROsClient) Put200Succeeded(ctx context.Context, product *Product) (result LROsPut200SucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Put200Succeeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put200SucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Put200Succeeded", nil, "Failure preparing request") @@ -1360,6 +1601,16 @@ func (client LROsClient) Put200SucceededResponder(resp *http.Response) (result P // Parameters: // product - product to put func (client LROsClient) Put200SucceededNoState(ctx context.Context, product *Product) (result LROsPut200SucceededNoStateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Put200SucceededNoState") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put200SucceededNoStatePreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Put200SucceededNoState", nil, "Failure preparing request") @@ -1421,6 +1672,16 @@ func (client LROsClient) Put200SucceededNoStateResponder(resp *http.Response) (r // Parameters: // product - product to put func (client LROsClient) Put200UpdatingSucceeded204(ctx context.Context, product *Product) (result LROsPut200UpdatingSucceeded204Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Put200UpdatingSucceeded204") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put200UpdatingSucceeded204Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Put200UpdatingSucceeded204", nil, "Failure preparing request") @@ -1482,6 +1743,16 @@ func (client LROsClient) Put200UpdatingSucceeded204Responder(resp *http.Response // Parameters: // product - product to put func (client LROsClient) Put201CreatingFailed200(ctx context.Context, product *Product) (result LROsPut201CreatingFailed200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Put201CreatingFailed200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put201CreatingFailed200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Put201CreatingFailed200", nil, "Failure preparing request") @@ -1543,6 +1814,16 @@ func (client LROsClient) Put201CreatingFailed200Responder(resp *http.Response) ( // Parameters: // product - product to put func (client LROsClient) Put201CreatingSucceeded200(ctx context.Context, product *Product) (result LROsPut201CreatingSucceeded200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Put201CreatingSucceeded200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put201CreatingSucceeded200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Put201CreatingSucceeded200", nil, "Failure preparing request") @@ -1603,6 +1884,16 @@ func (client LROsClient) Put201CreatingSucceeded200Responder(resp *http.Response // Parameters: // product - product to put func (client LROsClient) Put202Retry200(ctx context.Context, product *Product) (result LROsPut202Retry200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.Put202Retry200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put202Retry200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "Put202Retry200", nil, "Failure preparing request") @@ -1663,6 +1954,16 @@ func (client LROsClient) Put202Retry200Responder(resp *http.Response) (result Pr // Parameters: // product - product to put func (client LROsClient) PutAsyncNoHeaderInRetry(ctx context.Context, product *Product) (result LROsPutAsyncNoHeaderInRetryFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutAsyncNoHeaderInRetry") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncNoHeaderInRetryPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutAsyncNoHeaderInRetry", nil, "Failure preparing request") @@ -1722,6 +2023,16 @@ func (client LROsClient) PutAsyncNoHeaderInRetryResponder(resp *http.Response) ( // Parameters: // sku - sku to put func (client LROsClient) PutAsyncNonResource(ctx context.Context, sku *Sku) (result LROsPutAsyncNonResourceFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutAsyncNonResource") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncNonResourcePreparer(ctx, sku) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutAsyncNonResource", nil, "Failure preparing request") @@ -1783,6 +2094,16 @@ func (client LROsClient) PutAsyncNonResourceResponder(resp *http.Response) (resu // Parameters: // product - product to put func (client LROsClient) PutAsyncNoRetrycanceled(ctx context.Context, product *Product) (result LROsPutAsyncNoRetrycanceledFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutAsyncNoRetrycanceled") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncNoRetrycanceledPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutAsyncNoRetrycanceled", nil, "Failure preparing request") @@ -1844,6 +2165,16 @@ func (client LROsClient) PutAsyncNoRetrycanceledResponder(resp *http.Response) ( // Parameters: // product - product to put func (client LROsClient) PutAsyncNoRetrySucceeded(ctx context.Context, product *Product) (result LROsPutAsyncNoRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutAsyncNoRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncNoRetrySucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutAsyncNoRetrySucceeded", nil, "Failure preparing request") @@ -1905,6 +2236,16 @@ func (client LROsClient) PutAsyncNoRetrySucceededResponder(resp *http.Response) // Parameters: // product - product to put func (client LROsClient) PutAsyncRetryFailed(ctx context.Context, product *Product) (result LROsPutAsyncRetryFailedFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutAsyncRetryFailed") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRetryFailedPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutAsyncRetryFailed", nil, "Failure preparing request") @@ -1966,6 +2307,16 @@ func (client LROsClient) PutAsyncRetryFailedResponder(resp *http.Response) (resu // Parameters: // product - product to put func (client LROsClient) PutAsyncRetrySucceeded(ctx context.Context, product *Product) (result LROsPutAsyncRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutAsyncRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRetrySucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutAsyncRetrySucceeded", nil, "Failure preparing request") @@ -2025,6 +2376,16 @@ func (client LROsClient) PutAsyncRetrySucceededResponder(resp *http.Response) (r // Parameters: // product - sub Product to put func (client LROsClient) PutAsyncSubResource(ctx context.Context, product *SubProduct) (result LROsPutAsyncSubResourceFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutAsyncSubResource") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncSubResourcePreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutAsyncSubResource", nil, "Failure preparing request") @@ -2085,6 +2446,16 @@ func (client LROsClient) PutAsyncSubResourceResponder(resp *http.Response) (resu // Parameters: // product - product to put func (client LROsClient) PutNoHeaderInRetry(ctx context.Context, product *Product) (result LROsPutNoHeaderInRetryFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutNoHeaderInRetry") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutNoHeaderInRetryPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutNoHeaderInRetry", nil, "Failure preparing request") @@ -2144,6 +2515,16 @@ func (client LROsClient) PutNoHeaderInRetryResponder(resp *http.Response) (resul // Parameters: // sku - sku to put func (client LROsClient) PutNonResource(ctx context.Context, sku *Sku) (result LROsPutNonResourceFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutNonResource") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutNonResourcePreparer(ctx, sku) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutNonResource", nil, "Failure preparing request") @@ -2203,6 +2584,16 @@ func (client LROsClient) PutNonResourceResponder(resp *http.Response) (result Sk // Parameters: // product - sub Product to put func (client LROsClient) PutSubResource(ctx context.Context, product *SubProduct) (result LROsPutSubResourceFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsClient.PutSubResource") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutSubResourcePreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsClient", "PutSubResource", nil, "Failure preparing request") diff --git a/test/src/tests/generated/lro/lrosads.go b/test/src/tests/generated/lro/lrosads.go index 580290f9b..e5cb1590d 100644 --- a/test/src/tests/generated/lro/lrosads.go +++ b/test/src/tests/generated/lro/lrosads.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewLROSADsClientWithBaseURI(baseURI string) LROSADsClient { // Delete202NonRetry400 long running delete request, service returns a 202 with a location header func (client LROSADsClient) Delete202NonRetry400(ctx context.Context) (result LROSADsDelete202NonRetry400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.Delete202NonRetry400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete202NonRetry400Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "Delete202NonRetry400", nil, "Failure preparing request") @@ -82,6 +93,16 @@ func (client LROSADsClient) Delete202NonRetry400Responder(resp *http.Response) ( // Delete202RetryInvalidHeader long running delete request, service returns a 202 to the initial request receing a // reponse with an invalid 'Location' and 'Retry-After' headers func (client LROSADsClient) Delete202RetryInvalidHeader(ctx context.Context) (result LROSADsDelete202RetryInvalidHeaderFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.Delete202RetryInvalidHeader") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete202RetryInvalidHeaderPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "Delete202RetryInvalidHeader", nil, "Failure preparing request") @@ -133,6 +154,16 @@ func (client LROSADsClient) Delete202RetryInvalidHeaderResponder(resp *http.Resp // Delete204Succeeded long running delete request, service returns a 204 to the initial request, indicating success. func (client LROSADsClient) Delete204Succeeded(ctx context.Context) (result LROSADsDelete204SucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.Delete204Succeeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Delete204SucceededPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "Delete204Succeeded", nil, "Failure preparing request") @@ -185,6 +216,16 @@ func (client LROSADsClient) Delete204SucceededResponder(resp *http.Response) (re // DeleteAsyncRelativeRetry400 long running delete request, service returns a 202 to the initial request. Poll the // endpoint indicated in the Azure-AsyncOperation header for operation status func (client LROSADsClient) DeleteAsyncRelativeRetry400(ctx context.Context) (result LROSADsDeleteAsyncRelativeRetry400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.DeleteAsyncRelativeRetry400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncRelativeRetry400Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "DeleteAsyncRelativeRetry400", nil, "Failure preparing request") @@ -237,6 +278,16 @@ func (client LROSADsClient) DeleteAsyncRelativeRetry400Responder(resp *http.Resp // DeleteAsyncRelativeRetryInvalidHeader long running delete request, service returns a 202 to the initial request. The // endpoint indicated in the Azure-AsyncOperation header is invalid func (client LROSADsClient) DeleteAsyncRelativeRetryInvalidHeader(ctx context.Context) (result LROSADsDeleteAsyncRelativeRetryInvalidHeaderFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.DeleteAsyncRelativeRetryInvalidHeader") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncRelativeRetryInvalidHeaderPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "DeleteAsyncRelativeRetryInvalidHeader", nil, "Failure preparing request") @@ -289,6 +340,16 @@ func (client LROSADsClient) DeleteAsyncRelativeRetryInvalidHeaderResponder(resp // DeleteAsyncRelativeRetryInvalidJSONPolling long running delete request, service returns a 202 to the initial // request. Poll the endpoint indicated in the Azure-AsyncOperation header for operation status func (client LROSADsClient) DeleteAsyncRelativeRetryInvalidJSONPolling(ctx context.Context) (result LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.DeleteAsyncRelativeRetryInvalidJSONPolling") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncRelativeRetryInvalidJSONPollingPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "DeleteAsyncRelativeRetryInvalidJSONPolling", nil, "Failure preparing request") @@ -341,6 +402,16 @@ func (client LROSADsClient) DeleteAsyncRelativeRetryInvalidJSONPollingResponder( // DeleteAsyncRelativeRetryNoStatus long running delete request, service returns a 202 to the initial request. Poll the // endpoint indicated in the Azure-AsyncOperation header for operation status func (client LROSADsClient) DeleteAsyncRelativeRetryNoStatus(ctx context.Context) (result LROSADsDeleteAsyncRelativeRetryNoStatusFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.DeleteAsyncRelativeRetryNoStatus") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteAsyncRelativeRetryNoStatusPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "DeleteAsyncRelativeRetryNoStatus", nil, "Failure preparing request") @@ -392,6 +463,16 @@ func (client LROSADsClient) DeleteAsyncRelativeRetryNoStatusResponder(resp *http // DeleteNonRetry400 long running delete request, service returns a 400 with an error body func (client LROSADsClient) DeleteNonRetry400(ctx context.Context) (result LROSADsDeleteNonRetry400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.DeleteNonRetry400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DeleteNonRetry400Preparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "DeleteNonRetry400", nil, "Failure preparing request") @@ -446,6 +527,16 @@ func (client LROSADsClient) DeleteNonRetry400Responder(resp *http.Response) (res // Parameters: // product - product to put func (client LROSADsClient) Post202NoLocation(ctx context.Context, product *Product) (result LROSADsPost202NoLocationFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.Post202NoLocation") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post202NoLocationPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "Post202NoLocation", nil, "Failure preparing request") @@ -504,6 +595,16 @@ func (client LROSADsClient) Post202NoLocationResponder(resp *http.Response) (res // Parameters: // product - product to put func (client LROSADsClient) Post202NonRetry400(ctx context.Context, product *Product) (result LROSADsPost202NonRetry400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.Post202NonRetry400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post202NonRetry400Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "Post202NonRetry400", nil, "Failure preparing request") @@ -563,6 +664,16 @@ func (client LROSADsClient) Post202NonRetry400Responder(resp *http.Response) (re // Parameters: // product - product to put func (client LROSADsClient) Post202RetryInvalidHeader(ctx context.Context, product *Product) (result LROSADsPost202RetryInvalidHeaderFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.Post202RetryInvalidHeader") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post202RetryInvalidHeaderPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "Post202RetryInvalidHeader", nil, "Failure preparing request") @@ -622,6 +733,16 @@ func (client LROSADsClient) Post202RetryInvalidHeaderResponder(resp *http.Respon // Parameters: // product - product to put func (client LROSADsClient) PostAsyncRelativeRetry400(ctx context.Context, product *Product) (result LROSADsPostAsyncRelativeRetry400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PostAsyncRelativeRetry400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRelativeRetry400Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PostAsyncRelativeRetry400", nil, "Failure preparing request") @@ -682,6 +803,16 @@ func (client LROSADsClient) PostAsyncRelativeRetry400Responder(resp *http.Respon // Parameters: // product - product to put func (client LROSADsClient) PostAsyncRelativeRetryInvalidHeader(ctx context.Context, product *Product) (result LROSADsPostAsyncRelativeRetryInvalidHeaderFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PostAsyncRelativeRetryInvalidHeader") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRelativeRetryInvalidHeaderPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PostAsyncRelativeRetryInvalidHeader", nil, "Failure preparing request") @@ -742,6 +873,16 @@ func (client LROSADsClient) PostAsyncRelativeRetryInvalidHeaderResponder(resp *h // Parameters: // product - product to put func (client LROSADsClient) PostAsyncRelativeRetryInvalidJSONPolling(ctx context.Context, product *Product) (result LROSADsPostAsyncRelativeRetryInvalidJSONPollingFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PostAsyncRelativeRetryInvalidJSONPolling") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRelativeRetryInvalidJSONPollingPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PostAsyncRelativeRetryInvalidJSONPolling", nil, "Failure preparing request") @@ -802,6 +943,16 @@ func (client LROSADsClient) PostAsyncRelativeRetryInvalidJSONPollingResponder(re // Parameters: // product - product to put func (client LROSADsClient) PostAsyncRelativeRetryNoPayload(ctx context.Context, product *Product) (result LROSADsPostAsyncRelativeRetryNoPayloadFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PostAsyncRelativeRetryNoPayload") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRelativeRetryNoPayloadPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PostAsyncRelativeRetryNoPayload", nil, "Failure preparing request") @@ -860,6 +1011,16 @@ func (client LROSADsClient) PostAsyncRelativeRetryNoPayloadResponder(resp *http. // Parameters: // product - product to put func (client LROSADsClient) PostNonRetry400(ctx context.Context, product *Product) (result LROSADsPostNonRetry400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PostNonRetry400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostNonRetry400Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PostNonRetry400", nil, "Failure preparing request") @@ -919,6 +1080,16 @@ func (client LROSADsClient) PostNonRetry400Responder(resp *http.Response) (resul // Parameters: // product - product to put func (client LROSADsClient) Put200InvalidJSON(ctx context.Context, product *Product) (result LROSADsPut200InvalidJSONFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.Put200InvalidJSON") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put200InvalidJSONPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "Put200InvalidJSON", nil, "Failure preparing request") @@ -979,6 +1150,16 @@ func (client LROSADsClient) Put200InvalidJSONResponder(resp *http.Response) (res // Parameters: // product - product to put func (client LROSADsClient) PutAsyncRelativeRetry400(ctx context.Context, product *Product) (result LROSADsPutAsyncRelativeRetry400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutAsyncRelativeRetry400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRelativeRetry400Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutAsyncRelativeRetry400", nil, "Failure preparing request") @@ -1040,6 +1221,16 @@ func (client LROSADsClient) PutAsyncRelativeRetry400Responder(resp *http.Respons // Parameters: // product - product to put func (client LROSADsClient) PutAsyncRelativeRetryInvalidHeader(ctx context.Context, product *Product) (result LROSADsPutAsyncRelativeRetryInvalidHeaderFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutAsyncRelativeRetryInvalidHeader") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRelativeRetryInvalidHeaderPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutAsyncRelativeRetryInvalidHeader", nil, "Failure preparing request") @@ -1101,6 +1292,16 @@ func (client LROSADsClient) PutAsyncRelativeRetryInvalidHeaderResponder(resp *ht // Parameters: // product - product to put func (client LROSADsClient) PutAsyncRelativeRetryInvalidJSONPolling(ctx context.Context, product *Product) (result LROSADsPutAsyncRelativeRetryInvalidJSONPollingFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutAsyncRelativeRetryInvalidJSONPolling") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRelativeRetryInvalidJSONPollingPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutAsyncRelativeRetryInvalidJSONPolling", nil, "Failure preparing request") @@ -1162,6 +1363,16 @@ func (client LROSADsClient) PutAsyncRelativeRetryInvalidJSONPollingResponder(res // Parameters: // product - product to put func (client LROSADsClient) PutAsyncRelativeRetryNoStatus(ctx context.Context, product *Product) (result LROSADsPutAsyncRelativeRetryNoStatusFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutAsyncRelativeRetryNoStatus") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRelativeRetryNoStatusPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutAsyncRelativeRetryNoStatus", nil, "Failure preparing request") @@ -1223,6 +1434,16 @@ func (client LROSADsClient) PutAsyncRelativeRetryNoStatusResponder(resp *http.Re // Parameters: // product - product to put func (client LROSADsClient) PutAsyncRelativeRetryNoStatusPayload(ctx context.Context, product *Product) (result LROSADsPutAsyncRelativeRetryNoStatusPayloadFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutAsyncRelativeRetryNoStatusPayload") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRelativeRetryNoStatusPayloadPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutAsyncRelativeRetryNoStatusPayload", nil, "Failure preparing request") @@ -1283,6 +1504,16 @@ func (client LROSADsClient) PutAsyncRelativeRetryNoStatusPayloadResponder(resp * // Parameters: // product - product to put func (client LROSADsClient) PutError201NoProvisioningStatePayload(ctx context.Context, product *Product) (result LROSADsPutError201NoProvisioningStatePayloadFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutError201NoProvisioningStatePayload") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutError201NoProvisioningStatePayloadPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutError201NoProvisioningStatePayload", nil, "Failure preparing request") @@ -1343,6 +1574,16 @@ func (client LROSADsClient) PutError201NoProvisioningStatePayloadResponder(resp // Parameters: // product - product to put func (client LROSADsClient) PutNonRetry201Creating400(ctx context.Context, product *Product) (result LROSADsPutNonRetry201Creating400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutNonRetry201Creating400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutNonRetry201Creating400Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutNonRetry201Creating400", nil, "Failure preparing request") @@ -1403,6 +1644,16 @@ func (client LROSADsClient) PutNonRetry201Creating400Responder(resp *http.Respon // Parameters: // product - product to put func (client LROSADsClient) PutNonRetry201Creating400InvalidJSON(ctx context.Context, product *Product) (result LROSADsPutNonRetry201Creating400InvalidJSONFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutNonRetry201Creating400InvalidJSON") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutNonRetry201Creating400InvalidJSONPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutNonRetry201Creating400InvalidJSON", nil, "Failure preparing request") @@ -1462,6 +1713,16 @@ func (client LROSADsClient) PutNonRetry201Creating400InvalidJSONResponder(resp * // Parameters: // product - product to put func (client LROSADsClient) PutNonRetry400(ctx context.Context, product *Product) (result LROSADsPutNonRetry400Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROSADsClient.PutNonRetry400") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutNonRetry400Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROSADsClient", "PutNonRetry400", nil, "Failure preparing request") diff --git a/test/src/tests/generated/lro/lroscustomheader.go b/test/src/tests/generated/lro/lroscustomheader.go index 15e2040f4..7ee9d5d8c 100644 --- a/test/src/tests/generated/lro/lroscustomheader.go +++ b/test/src/tests/generated/lro/lroscustomheader.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -34,6 +35,16 @@ func NewLROsCustomHeaderClientWithBaseURI(baseURI string) LROsCustomHeaderClient // Parameters: // product - product to put func (client LROsCustomHeaderClient) Post202Retry200(ctx context.Context, product *Product) (result LROsCustomHeaderPost202Retry200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsCustomHeaderClient.Post202Retry200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Post202Retry200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsCustomHeaderClient", "Post202Retry200", nil, "Failure preparing request") @@ -94,6 +105,16 @@ func (client LROsCustomHeaderClient) Post202Retry200Responder(resp *http.Respons // Parameters: // product - product to put func (client LROsCustomHeaderClient) PostAsyncRetrySucceeded(ctx context.Context, product *Product) (result LROsCustomHeaderPostAsyncRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsCustomHeaderClient.PostAsyncRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostAsyncRetrySucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsCustomHeaderClient", "PostAsyncRetrySucceeded", nil, "Failure preparing request") @@ -155,6 +176,16 @@ func (client LROsCustomHeaderClient) PostAsyncRetrySucceededResponder(resp *http // Parameters: // product - product to put func (client LROsCustomHeaderClient) Put201CreatingSucceeded200(ctx context.Context, product *Product) (result LROsCustomHeaderPut201CreatingSucceeded200Future, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsCustomHeaderClient.Put201CreatingSucceeded200") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Put201CreatingSucceeded200Preparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsCustomHeaderClient", "Put201CreatingSucceeded200", nil, "Failure preparing request") @@ -216,6 +247,16 @@ func (client LROsCustomHeaderClient) Put201CreatingSucceeded200Responder(resp *h // Parameters: // product - product to put func (client LROsCustomHeaderClient) PutAsyncRetrySucceeded(ctx context.Context, product *Product) (result LROsCustomHeaderPutAsyncRetrySucceededFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LROsCustomHeaderClient.PutAsyncRetrySucceeded") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutAsyncRetrySucceededPreparer(ctx, product) if err != nil { err = autorest.NewErrorWithError(err, "lrogroup.LROsCustomHeaderClient", "PutAsyncRetrySucceeded", nil, "Failure preparing request") diff --git a/test/src/tests/generated/lro/models.go b/test/src/tests/generated/lro/models.go index 155ddd94f..b730beab0 100644 --- a/test/src/tests/generated/lro/models.go +++ b/test/src/tests/generated/lro/models.go @@ -13,6 +13,9 @@ import ( "net/http" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/lro" + // ProvisioningStateValues enumerates the values for provisioning state values. type ProvisioningStateValues string @@ -118,8 +121,8 @@ type CloudError struct { Message *string `json:"message,omitempty"` } -// LRORetrysDelete202Retry200Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LRORetrysDelete202Retry200Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LRORetrysDelete202Retry200Future struct { azure.Future } @@ -141,8 +144,8 @@ func (future *LRORetrysDelete202Retry200Future) Result(client LRORetrysClient) ( return } -// LRORetrysDeleteAsyncRelativeRetrySucceededFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LRORetrysDeleteAsyncRelativeRetrySucceededFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LRORetrysDeleteAsyncRelativeRetrySucceededFuture struct { azure.Future } @@ -164,8 +167,8 @@ func (future *LRORetrysDeleteAsyncRelativeRetrySucceededFuture) Result(client LR return } -// LRORetrysDeleteProvisioning202Accepted200SucceededFuture an abstraction for monitoring and retrieving the -// results of a long-running operation. +// LRORetrysDeleteProvisioning202Accepted200SucceededFuture an abstraction for monitoring and retrieving +// the results of a long-running operation. type LRORetrysDeleteProvisioning202Accepted200SucceededFuture struct { azure.Future } @@ -193,8 +196,8 @@ func (future *LRORetrysDeleteProvisioning202Accepted200SucceededFuture) Result(c return } -// LRORetrysPost202Retry200Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LRORetrysPost202Retry200Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LRORetrysPost202Retry200Future struct { azure.Future } @@ -216,8 +219,8 @@ func (future *LRORetrysPost202Retry200Future) Result(client LRORetrysClient) (ar return } -// LRORetrysPostAsyncRelativeRetrySucceededFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LRORetrysPostAsyncRelativeRetrySucceededFuture an abstraction for monitoring and retrieving the results +// of a long-running operation. type LRORetrysPostAsyncRelativeRetrySucceededFuture struct { azure.Future } @@ -268,8 +271,8 @@ func (future *LRORetrysPut201CreatingSucceeded200Future) Result(client LRORetrys return } -// LRORetrysPutAsyncRelativeRetrySucceededFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LRORetrysPutAsyncRelativeRetrySucceededFuture an abstraction for monitoring and retrieving the results +// of a long-running operation. type LRORetrysPutAsyncRelativeRetrySucceededFuture struct { azure.Future } @@ -297,8 +300,8 @@ func (future *LRORetrysPutAsyncRelativeRetrySucceededFuture) Result(client LRORe return } -// LROSADsDelete202NonRetry400Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROSADsDelete202NonRetry400Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROSADsDelete202NonRetry400Future struct { azure.Future } @@ -343,8 +346,8 @@ func (future *LROSADsDelete202RetryInvalidHeaderFuture) Result(client LROSADsCli return } -// LROSADsDelete204SucceededFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROSADsDelete204SucceededFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROSADsDelete204SucceededFuture struct { azure.Future } @@ -389,8 +392,8 @@ func (future *LROSADsDeleteAsyncRelativeRetry400Future) Result(client LROSADsCli return } -// LROSADsDeleteAsyncRelativeRetryInvalidHeaderFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROSADsDeleteAsyncRelativeRetryInvalidHeaderFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROSADsDeleteAsyncRelativeRetryInvalidHeaderFuture struct { azure.Future } @@ -412,8 +415,8 @@ func (future *LROSADsDeleteAsyncRelativeRetryInvalidHeaderFuture) Result(client return } -// LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingFuture an abstraction for monitoring and retrieving the results -// of a long-running operation. +// LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingFuture struct { azure.Future } @@ -435,8 +438,8 @@ func (future *LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingFuture) Result(cl return } -// LROSADsDeleteAsyncRelativeRetryNoStatusFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROSADsDeleteAsyncRelativeRetryNoStatusFuture an abstraction for monitoring and retrieving the results +// of a long-running operation. type LROSADsDeleteAsyncRelativeRetryNoStatusFuture struct { azure.Future } @@ -458,8 +461,8 @@ func (future *LROSADsDeleteAsyncRelativeRetryNoStatusFuture) Result(client LROSA return } -// LROSADsDeleteNonRetry400Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROSADsDeleteNonRetry400Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROSADsDeleteNonRetry400Future struct { azure.Future } @@ -481,8 +484,8 @@ func (future *LROSADsDeleteNonRetry400Future) Result(client LROSADsClient) (ar a return } -// LROSADsPost202NoLocationFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROSADsPost202NoLocationFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROSADsPost202NoLocationFuture struct { azure.Future } @@ -504,8 +507,8 @@ func (future *LROSADsPost202NoLocationFuture) Result(client LROSADsClient) (ar a return } -// LROSADsPost202NonRetry400Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROSADsPost202NonRetry400Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROSADsPost202NonRetry400Future struct { azure.Future } @@ -573,8 +576,8 @@ func (future *LROSADsPostAsyncRelativeRetry400Future) Result(client LROSADsClien return } -// LROSADsPostAsyncRelativeRetryInvalidHeaderFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROSADsPostAsyncRelativeRetryInvalidHeaderFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROSADsPostAsyncRelativeRetryInvalidHeaderFuture struct { azure.Future } @@ -596,8 +599,8 @@ func (future *LROSADsPostAsyncRelativeRetryInvalidHeaderFuture) Result(client LR return } -// LROSADsPostAsyncRelativeRetryInvalidJSONPollingFuture an abstraction for monitoring and retrieving the results -// of a long-running operation. +// LROSADsPostAsyncRelativeRetryInvalidJSONPollingFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROSADsPostAsyncRelativeRetryInvalidJSONPollingFuture struct { azure.Future } @@ -619,8 +622,8 @@ func (future *LROSADsPostAsyncRelativeRetryInvalidJSONPollingFuture) Result(clie return } -// LROSADsPostAsyncRelativeRetryNoPayloadFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROSADsPostAsyncRelativeRetryNoPayloadFuture an abstraction for monitoring and retrieving the results of +// a long-running operation. type LROSADsPostAsyncRelativeRetryNoPayloadFuture struct { azure.Future } @@ -665,8 +668,8 @@ func (future *LROSADsPostNonRetry400Future) Result(client LROSADsClient) (ar aut return } -// LROSADsPut200InvalidJSONFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROSADsPut200InvalidJSONFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROSADsPut200InvalidJSONFuture struct { azure.Future } @@ -694,8 +697,8 @@ func (future *LROSADsPut200InvalidJSONFuture) Result(client LROSADsClient) (p Pr return } -// LROSADsPutAsyncRelativeRetry400Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROSADsPutAsyncRelativeRetry400Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROSADsPutAsyncRelativeRetry400Future struct { azure.Future } @@ -723,8 +726,8 @@ func (future *LROSADsPutAsyncRelativeRetry400Future) Result(client LROSADsClient return } -// LROSADsPutAsyncRelativeRetryInvalidHeaderFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROSADsPutAsyncRelativeRetryInvalidHeaderFuture an abstraction for monitoring and retrieving the results +// of a long-running operation. type LROSADsPutAsyncRelativeRetryInvalidHeaderFuture struct { azure.Future } @@ -752,8 +755,8 @@ func (future *LROSADsPutAsyncRelativeRetryInvalidHeaderFuture) Result(client LRO return } -// LROSADsPutAsyncRelativeRetryInvalidJSONPollingFuture an abstraction for monitoring and retrieving the results of -// a long-running operation. +// LROSADsPutAsyncRelativeRetryInvalidJSONPollingFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROSADsPutAsyncRelativeRetryInvalidJSONPollingFuture struct { azure.Future } @@ -810,8 +813,8 @@ func (future *LROSADsPutAsyncRelativeRetryNoStatusFuture) Result(client LROSADsC return } -// LROSADsPutAsyncRelativeRetryNoStatusPayloadFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROSADsPutAsyncRelativeRetryNoStatusPayloadFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROSADsPutAsyncRelativeRetryNoStatusPayloadFuture struct { azure.Future } @@ -839,8 +842,8 @@ func (future *LROSADsPutAsyncRelativeRetryNoStatusPayloadFuture) Result(client L return } -// LROSADsPutError201NoProvisioningStatePayloadFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROSADsPutError201NoProvisioningStatePayloadFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROSADsPutError201NoProvisioningStatePayloadFuture struct { azure.Future } @@ -897,8 +900,8 @@ func (future *LROSADsPutNonRetry201Creating400Future) Result(client LROSADsClien return } -// LROSADsPutNonRetry201Creating400InvalidJSONFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROSADsPutNonRetry201Creating400InvalidJSONFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROSADsPutNonRetry201Creating400InvalidJSONFuture struct { azure.Future } @@ -955,8 +958,8 @@ func (future *LROSADsPutNonRetry400Future) Result(client LROSADsClient) (p Produ return } -// LROsCustomHeaderPost202Retry200Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsCustomHeaderPost202Retry200Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsCustomHeaderPost202Retry200Future struct { azure.Future } @@ -978,8 +981,8 @@ func (future *LROsCustomHeaderPost202Retry200Future) Result(client LROsCustomHea return } -// LROsCustomHeaderPostAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROsCustomHeaderPostAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results +// of a long-running operation. type LROsCustomHeaderPostAsyncRetrySucceededFuture struct { azure.Future } @@ -1001,8 +1004,8 @@ func (future *LROsCustomHeaderPostAsyncRetrySucceededFuture) Result(client LROsC return } -// LROsCustomHeaderPut201CreatingSucceeded200Future an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROsCustomHeaderPut201CreatingSucceeded200Future an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROsCustomHeaderPut201CreatingSucceeded200Future struct { azure.Future } @@ -1030,8 +1033,8 @@ func (future *LROsCustomHeaderPut201CreatingSucceeded200Future) Result(client LR return } -// LROsCustomHeaderPutAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROsCustomHeaderPutAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of +// a long-running operation. type LROsCustomHeaderPutAsyncRetrySucceededFuture struct { azure.Future } @@ -1140,8 +1143,8 @@ func (future *LROsDelete204SucceededFuture) Result(client LROsClient) (ar autore return } -// LROsDeleteAsyncNoHeaderInRetryFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsDeleteAsyncNoHeaderInRetryFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsDeleteAsyncNoHeaderInRetryFuture struct { azure.Future } @@ -1163,8 +1166,8 @@ func (future *LROsDeleteAsyncNoHeaderInRetryFuture) Result(client LROsClient) (a return } -// LROsDeleteAsyncNoRetrySucceededFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsDeleteAsyncNoRetrySucceededFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsDeleteAsyncNoRetrySucceededFuture struct { azure.Future } @@ -1186,8 +1189,8 @@ func (future *LROsDeleteAsyncNoRetrySucceededFuture) Result(client LROsClient) ( return } -// LROsDeleteAsyncRetrycanceledFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsDeleteAsyncRetrycanceledFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsDeleteAsyncRetrycanceledFuture struct { azure.Future } @@ -1209,8 +1212,8 @@ func (future *LROsDeleteAsyncRetrycanceledFuture) Result(client LROsClient) (ar return } -// LROsDeleteAsyncRetryFailedFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsDeleteAsyncRetryFailedFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsDeleteAsyncRetryFailedFuture struct { azure.Future } @@ -1232,8 +1235,8 @@ func (future *LROsDeleteAsyncRetryFailedFuture) Result(client LROsClient) (ar au return } -// LROsDeleteAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsDeleteAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsDeleteAsyncRetrySucceededFuture struct { azure.Future } @@ -1255,8 +1258,8 @@ func (future *LROsDeleteAsyncRetrySucceededFuture) Result(client LROsClient) (ar return } -// LROsDeleteNoHeaderInRetryFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsDeleteNoHeaderInRetryFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsDeleteNoHeaderInRetryFuture struct { azure.Future } @@ -1278,8 +1281,8 @@ func (future *LROsDeleteNoHeaderInRetryFuture) Result(client LROsClient) (ar aut return } -// LROsDeleteProvisioning202Accepted200SucceededFuture an abstraction for monitoring and retrieving the results of -// a long-running operation. +// LROsDeleteProvisioning202Accepted200SucceededFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROsDeleteProvisioning202Accepted200SucceededFuture struct { azure.Future } @@ -1307,8 +1310,8 @@ func (future *LROsDeleteProvisioning202Accepted200SucceededFuture) Result(client return } -// LROsDeleteProvisioning202Deletingcanceled200Future an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROsDeleteProvisioning202Deletingcanceled200Future an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROsDeleteProvisioning202Deletingcanceled200Future struct { azure.Future } @@ -1336,8 +1339,8 @@ func (future *LROsDeleteProvisioning202Deletingcanceled200Future) Result(client return } -// LROsDeleteProvisioning202DeletingFailed200Future an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROsDeleteProvisioning202DeletingFailed200Future an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROsDeleteProvisioning202DeletingFailed200Future struct { azure.Future } @@ -1423,7 +1426,8 @@ func (future *LROsPost202NoRetry204Future) Result(client LROsClient) (p Product, return } -// LROsPost202Retry200Future an abstraction for monitoring and retrieving the results of a long-running operation. +// LROsPost202Retry200Future an abstraction for monitoring and retrieving the results of a long-running +// operation. type LROsPost202Retry200Future struct { azure.Future } @@ -1445,8 +1449,8 @@ func (future *LROsPost202Retry200Future) Result(client LROsClient) (ar autorest. return } -// LROsPostAsyncNoRetrySucceededFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPostAsyncNoRetrySucceededFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPostAsyncNoRetrySucceededFuture struct { azure.Future } @@ -1474,8 +1478,8 @@ func (future *LROsPostAsyncNoRetrySucceededFuture) Result(client LROsClient) (p return } -// LROsPostAsyncRetrycanceledFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPostAsyncRetrycanceledFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPostAsyncRetrycanceledFuture struct { azure.Future } @@ -1497,8 +1501,8 @@ func (future *LROsPostAsyncRetrycanceledFuture) Result(client LROsClient) (ar au return } -// LROsPostAsyncRetryFailedFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPostAsyncRetryFailedFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPostAsyncRetryFailedFuture struct { azure.Future } @@ -1520,8 +1524,8 @@ func (future *LROsPostAsyncRetryFailedFuture) Result(client LROsClient) (ar auto return } -// LROsPostAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPostAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPostAsyncRetrySucceededFuture struct { azure.Future } @@ -1549,8 +1553,8 @@ func (future *LROsPostAsyncRetrySucceededFuture) Result(client LROsClient) (p Pr return } -// LROsPostDoubleHeadersFinalAzureHeaderGetDefaultFuture an abstraction for monitoring and retrieving the results -// of a long-running operation. +// LROsPostDoubleHeadersFinalAzureHeaderGetDefaultFuture an abstraction for monitoring and retrieving the +// results of a long-running operation. type LROsPostDoubleHeadersFinalAzureHeaderGetDefaultFuture struct { azure.Future } @@ -1578,8 +1582,8 @@ func (future *LROsPostDoubleHeadersFinalAzureHeaderGetDefaultFuture) Result(clie return } -// LROsPostDoubleHeadersFinalAzureHeaderGetFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROsPostDoubleHeadersFinalAzureHeaderGetFuture an abstraction for monitoring and retrieving the results +// of a long-running operation. type LROsPostDoubleHeadersFinalAzureHeaderGetFuture struct { azure.Future } @@ -1607,8 +1611,8 @@ func (future *LROsPostDoubleHeadersFinalAzureHeaderGetFuture) Result(client LROs return } -// LROsPostDoubleHeadersFinalLocationGetFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. +// LROsPostDoubleHeadersFinalLocationGetFuture an abstraction for monitoring and retrieving the results of +// a long-running operation. type LROsPostDoubleHeadersFinalLocationGetFuture struct { azure.Future } @@ -1636,8 +1640,8 @@ func (future *LROsPostDoubleHeadersFinalLocationGetFuture) Result(client LROsCli return } -// LROsPut200Acceptedcanceled200Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPut200Acceptedcanceled200Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPut200Acceptedcanceled200Future struct { azure.Future } @@ -1665,7 +1669,8 @@ func (future *LROsPut200Acceptedcanceled200Future) Result(client LROsClient) (p return } -// LROsPut200SucceededFuture an abstraction for monitoring and retrieving the results of a long-running operation. +// LROsPut200SucceededFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. type LROsPut200SucceededFuture struct { azure.Future } @@ -1693,8 +1698,8 @@ func (future *LROsPut200SucceededFuture) Result(client LROsClient) (p Product, e return } -// LROsPut200SucceededNoStateFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPut200SucceededNoStateFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPut200SucceededNoStateFuture struct { azure.Future } @@ -1722,8 +1727,8 @@ func (future *LROsPut200SucceededNoStateFuture) Result(client LROsClient) (p Pro return } -// LROsPut200UpdatingSucceeded204Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPut200UpdatingSucceeded204Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPut200UpdatingSucceeded204Future struct { azure.Future } @@ -1751,8 +1756,8 @@ func (future *LROsPut200UpdatingSucceeded204Future) Result(client LROsClient) (p return } -// LROsPut201CreatingFailed200Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPut201CreatingFailed200Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPut201CreatingFailed200Future struct { azure.Future } @@ -1780,8 +1785,8 @@ func (future *LROsPut201CreatingFailed200Future) Result(client LROsClient) (p Pr return } -// LROsPut201CreatingSucceeded200Future an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPut201CreatingSucceeded200Future an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPut201CreatingSucceeded200Future struct { azure.Future } @@ -1809,7 +1814,8 @@ func (future *LROsPut201CreatingSucceeded200Future) Result(client LROsClient) (p return } -// LROsPut202Retry200Future an abstraction for monitoring and retrieving the results of a long-running operation. +// LROsPut202Retry200Future an abstraction for monitoring and retrieving the results of a long-running +// operation. type LROsPut202Retry200Future struct { azure.Future } @@ -1837,8 +1843,8 @@ func (future *LROsPut202Retry200Future) Result(client LROsClient) (p Product, er return } -// LROsPutAsyncNoHeaderInRetryFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPutAsyncNoHeaderInRetryFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPutAsyncNoHeaderInRetryFuture struct { azure.Future } @@ -1895,8 +1901,8 @@ func (future *LROsPutAsyncNonResourceFuture) Result(client LROsClient) (s Sku, e return } -// LROsPutAsyncNoRetrycanceledFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPutAsyncNoRetrycanceledFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPutAsyncNoRetrycanceledFuture struct { azure.Future } @@ -1924,8 +1930,8 @@ func (future *LROsPutAsyncNoRetrycanceledFuture) Result(client LROsClient) (p Pr return } -// LROsPutAsyncNoRetrySucceededFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPutAsyncNoRetrySucceededFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPutAsyncNoRetrySucceededFuture struct { azure.Future } @@ -1982,8 +1988,8 @@ func (future *LROsPutAsyncRetryFailedFuture) Result(client LROsClient) (p Produc return } -// LROsPutAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// LROsPutAsyncRetrySucceededFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type LROsPutAsyncRetrySucceededFuture struct { azure.Future } @@ -2069,7 +2075,8 @@ func (future *LROsPutNoHeaderInRetryFuture) Result(client LROsClient) (p Product return } -// LROsPutNonResourceFuture an abstraction for monitoring and retrieving the results of a long-running operation. +// LROsPutNonResourceFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. type LROsPutNonResourceFuture struct { azure.Future } @@ -2097,7 +2104,8 @@ func (future *LROsPutNonResourceFuture) Result(client LROsClient) (s Sku, err er return } -// LROsPutSubResourceFuture an abstraction for monitoring and retrieving the results of a long-running operation. +// LROsPutSubResourceFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. type LROsPutSubResourceFuture struct { azure.Future } diff --git a/test/src/tests/generated/model-flattening/client.go b/test/src/tests/generated/model-flattening/client.go index ff15602e5..c76ec1be4 100644 --- a/test/src/tests/generated/model-flattening/client.go +++ b/test/src/tests/generated/model-flattening/client.go @@ -14,6 +14,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -43,6 +44,16 @@ func NewWithBaseURI(baseURI string) BaseClient { // GetArray get External Resource as an Array func (client BaseClient) GetArray(ctx context.Context) (result ListFlattenedProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetArray") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetArrayPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "modelflatteninggroup.BaseClient", "GetArray", nil, "Failure preparing request") @@ -95,6 +106,16 @@ func (client BaseClient) GetArrayResponder(resp *http.Response) (result ListFlat // GetDictionary get External Resource as a Dictionary func (client BaseClient) GetDictionary(ctx context.Context) (result SetFlattenedProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetDictionary") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetDictionaryPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "modelflatteninggroup.BaseClient", "GetDictionary", nil, "Failure preparing request") @@ -147,6 +168,16 @@ func (client BaseClient) GetDictionaryResponder(resp *http.Response) (result Set // GetResourceCollection get External Resource as a ResourceCollection func (client BaseClient) GetResourceCollection(ctx context.Context) (result ResourceCollection, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetResourceCollection") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetResourceCollectionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "modelflatteninggroup.BaseClient", "GetResourceCollection", nil, "Failure preparing request") @@ -200,6 +231,16 @@ func (client BaseClient) GetResourceCollectionResponder(resp *http.Response) (re // GetWrappedArray no need to have a route in Express server for this operation. Used to verify the type flattened is // not removed if it's referenced in an array func (client BaseClient) GetWrappedArray(ctx context.Context) (result ListProductWrapper, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetWrappedArray") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetWrappedArrayPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "modelflatteninggroup.BaseClient", "GetWrappedArray", nil, "Failure preparing request") @@ -254,6 +295,16 @@ func (client BaseClient) GetWrappedArrayResponder(resp *http.Response) (result L // Parameters: // simpleBodyProduct - simple body product to post func (client BaseClient) PostFlattenedSimpleProduct(ctx context.Context, simpleBodyProduct *SimpleProduct) (result SimpleProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PostFlattenedSimpleProduct") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: simpleBodyProduct, Constraints: []validation.Constraint{{Target: "simpleBodyProduct", Name: validation.Null, Rule: false, @@ -324,6 +375,16 @@ func (client BaseClient) PostFlattenedSimpleProductResponder(resp *http.Response // Parameters: // resourceArray - external Resource as an Array to put func (client BaseClient) PutArray(ctx context.Context, resourceArray []Resource) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PutArray") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutArrayPreparer(ctx, resourceArray) if err != nil { err = autorest.NewErrorWithError(err, "modelflatteninggroup.BaseClient", "PutArray", nil, "Failure preparing request") @@ -382,6 +443,16 @@ func (client BaseClient) PutArrayResponder(resp *http.Response) (result autorest // Parameters: // resourceDictionary - external Resource as a Dictionary to put func (client BaseClient) PutDictionary(ctx context.Context, resourceDictionary map[string]*FlattenedProduct) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PutDictionary") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutDictionaryPreparer(ctx, resourceDictionary) if err != nil { err = autorest.NewErrorWithError(err, "modelflatteninggroup.BaseClient", "PutDictionary", nil, "Failure preparing request") @@ -440,6 +511,16 @@ func (client BaseClient) PutDictionaryResponder(resp *http.Response) (result aut // Parameters: // resourceComplexObject - external Resource as a ResourceCollection to put func (client BaseClient) PutResourceCollection(ctx context.Context, resourceComplexObject *ResourceCollection) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PutResourceCollection") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutResourceCollectionPreparer(ctx, resourceComplexObject) if err != nil { err = autorest.NewErrorWithError(err, "modelflatteninggroup.BaseClient", "PutResourceCollection", nil, "Failure preparing request") @@ -498,6 +579,16 @@ func (client BaseClient) PutResourceCollectionResponder(resp *http.Response) (re // Parameters: // simpleBodyProduct - simple body product to put func (client BaseClient) PutSimpleProduct(ctx context.Context, simpleBodyProduct *SimpleProduct) (result SimpleProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PutSimpleProduct") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: simpleBodyProduct, Constraints: []validation.Constraint{{Target: "simpleBodyProduct", Name: validation.Null, Rule: false, @@ -569,6 +660,16 @@ func (client BaseClient) PutSimpleProductResponder(resp *http.Response) (result // name - product name with value 'groupproduct' // simpleBodyProduct - simple body product to put func (client BaseClient) PutSimpleProductWithGrouping(ctx context.Context, name string, simpleBodyProduct *SimpleProduct) (result SimpleProduct, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PutSimpleProductWithGrouping") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: simpleBodyProduct, Constraints: []validation.Constraint{{Target: "simpleBodyProduct", Name: validation.Null, Rule: false, @@ -644,6 +745,16 @@ func (client BaseClient) PutSimpleProductWithGroupingResponder(resp *http.Respon // Parameters: // resourceArray - external Resource as an Array to put func (client BaseClient) PutWrappedArray(ctx context.Context, resourceArray []WrappedProduct) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PutWrappedArray") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutWrappedArrayPreparer(ctx, resourceArray) if err != nil { err = autorest.NewErrorWithError(err, "modelflatteninggroup.BaseClient", "PutWrappedArray", nil, "Failure preparing request") diff --git a/test/src/tests/generated/model-flattening/models.go b/test/src/tests/generated/model-flattening/models.go index 55e4925df..e37af7a3a 100644 --- a/test/src/tests/generated/model-flattening/models.go +++ b/test/src/tests/generated/model-flattening/models.go @@ -11,6 +11,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/model-flattening" + // ProvisioningStateValues enumerates the values for provisioning state values. type ProvisioningStateValues string diff --git a/test/src/tests/generated/more-custom-base-uri/models.go b/test/src/tests/generated/more-custom-base-uri/models.go index 1412cbe95..ee89cd491 100644 --- a/test/src/tests/generated/more-custom-base-uri/models.go +++ b/test/src/tests/generated/more-custom-base-uri/models.go @@ -6,6 +6,9 @@ package morecustombaseurigroup // Code generated by Microsoft (R) AutoRest Code Generator. // Changes may cause incorrect behavior and will be lost if the code is regenerated. +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/more-custom-base-uri" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/more-custom-base-uri/paths.go b/test/src/tests/generated/more-custom-base-uri/paths.go index 41dab0393..bd42bc149 100644 --- a/test/src/tests/generated/more-custom-base-uri/paths.go +++ b/test/src/tests/generated/more-custom-base-uri/paths.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewPathsClient(subscriptionID string) PathsClient { // keyName - the key name with value 'key1'. // keyVersion - the key version. Default value 'v1'. func (client PathsClient) GetEmpty(ctx context.Context, vault string, secret string, keyName string, keyVersion string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.GetEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetEmptyPreparer(ctx, vault, secret, keyName, keyVersion) if err != nil { err = autorest.NewErrorWithError(err, "morecustombaseurigroup.PathsClient", "GetEmpty", nil, "Failure preparing request") diff --git a/test/src/tests/generated/paging/models.go b/test/src/tests/generated/paging/models.go index 27a712f67..ed7907d84 100644 --- a/test/src/tests/generated/paging/models.go +++ b/test/src/tests/generated/paging/models.go @@ -7,12 +7,17 @@ package paginggroup // Changes may cause incorrect behavior and will be lost if the code is regenerated. import ( + "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/to" + "github.com/Azure/go-autorest/tracing" "net/http" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/paging" + // Status enumerates the values for status. type Status string @@ -59,14 +64,24 @@ type OdataProductResultIterator struct { page OdataProductResultPage } -// Next advances to the next value. If there was an error making +// NextWithContext advances to the next value. If there was an error making // the request the iterator does not advance and the error is returned. -func (iter *OdataProductResultIterator) Next() error { +func (iter *OdataProductResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OdataProductResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } iter.i++ if iter.i < len(iter.page.Values()) { return nil } - err := iter.page.Next() + err = iter.page.NextWithContext(ctx) if err != nil { iter.i-- return err @@ -75,6 +90,13 @@ func (iter *OdataProductResultIterator) Next() error { return nil } +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *OdataProductResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + // NotDone returns true if the enumeration should be started or is not yet complete. func (iter OdataProductResultIterator) NotDone() bool { return iter.page.NotDone() && iter.i < len(iter.page.Values()) @@ -101,11 +123,11 @@ func (opr OdataProductResult) IsEmpty() bool { // odataProductResultPreparer prepares a request to retrieve the next set of results. // It returns nil if no more results exist. -func (opr OdataProductResult) odataProductResultPreparer() (*http.Request, error) { +func (opr OdataProductResult) odataProductResultPreparer(ctx context.Context) (*http.Request, error) { if opr.OdataNextLink == nil || len(to.String(opr.OdataNextLink)) < 1 { return nil, nil } - return autorest.Prepare(&http.Request{}, + return autorest.Prepare((&http.Request{}).WithContext(ctx), autorest.AsJSON(), autorest.AsGet(), autorest.WithBaseURL(to.String(opr.OdataNextLink))) @@ -113,14 +135,24 @@ func (opr OdataProductResult) odataProductResultPreparer() (*http.Request, error // OdataProductResultPage contains a page of Product values. type OdataProductResultPage struct { - fn func(OdataProductResult) (OdataProductResult, error) + fn func(context.Context, OdataProductResult) (OdataProductResult, error) opr OdataProductResult } -// Next advances to the next page of values. If there was an error making +// NextWithContext advances to the next page of values. If there was an error making // the request the page does not advance and the error is returned. -func (page *OdataProductResultPage) Next() error { - next, err := page.fn(page.opr) +func (page *OdataProductResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OdataProductResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.opr) if err != nil { return err } @@ -128,6 +160,13 @@ func (page *OdataProductResultPage) Next() error { return nil } +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *OdataProductResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + // NotDone returns true if the page enumeration should be started or is not yet complete. func (page OdataProductResultPage) NotDone() bool { return !page.opr.IsEmpty() @@ -152,8 +191,8 @@ type OperationResult struct { Status Status `json:"status,omitempty"` } -// PagingGetMultiplePagesLROAllFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// PagingGetMultiplePagesLROAllFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type PagingGetMultiplePagesLROAllFuture struct { azure.Future } @@ -181,8 +220,8 @@ func (future *PagingGetMultiplePagesLROAllFuture) Result(client PagingClient) (p return } -// PagingGetMultiplePagesLROFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. +// PagingGetMultiplePagesLROFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. type PagingGetMultiplePagesLROFuture struct { azure.Future } @@ -234,14 +273,24 @@ type ProductResultIterator struct { page ProductResultPage } -// Next advances to the next value. If there was an error making +// NextWithContext advances to the next value. If there was an error making // the request the iterator does not advance and the error is returned. -func (iter *ProductResultIterator) Next() error { +func (iter *ProductResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ProductResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } iter.i++ if iter.i < len(iter.page.Values()) { return nil } - err := iter.page.Next() + err = iter.page.NextWithContext(ctx) if err != nil { iter.i-- return err @@ -250,6 +299,13 @@ func (iter *ProductResultIterator) Next() error { return nil } +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *ProductResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + // NotDone returns true if the enumeration should be started or is not yet complete. func (iter ProductResultIterator) NotDone() bool { return iter.page.NotDone() && iter.i < len(iter.page.Values()) @@ -276,11 +332,11 @@ func (pr ProductResult) IsEmpty() bool { // productResultPreparer prepares a request to retrieve the next set of results. // It returns nil if no more results exist. -func (pr ProductResult) productResultPreparer() (*http.Request, error) { +func (pr ProductResult) productResultPreparer(ctx context.Context) (*http.Request, error) { if pr.NextLink == nil || len(to.String(pr.NextLink)) < 1 { return nil, nil } - return autorest.Prepare(&http.Request{}, + return autorest.Prepare((&http.Request{}).WithContext(ctx), autorest.AsJSON(), autorest.AsGet(), autorest.WithBaseURL(to.String(pr.NextLink))) @@ -288,14 +344,24 @@ func (pr ProductResult) productResultPreparer() (*http.Request, error) { // ProductResultPage contains a page of Product values. type ProductResultPage struct { - fn func(ProductResult) (ProductResult, error) + fn func(context.Context, ProductResult) (ProductResult, error) pr ProductResult } -// Next advances to the next page of values. If there was an error making +// NextWithContext advances to the next page of values. If there was an error making // the request the page does not advance and the error is returned. -func (page *ProductResultPage) Next() error { - next, err := page.fn(page.pr) +func (page *ProductResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ProductResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.pr) if err != nil { return err } @@ -303,6 +369,13 @@ func (page *ProductResultPage) Next() error { return nil } +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *ProductResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + // NotDone returns true if the page enumeration should be started or is not yet complete. func (page ProductResultPage) NotDone() bool { return !page.pr.IsEmpty() diff --git a/test/src/tests/generated/paging/paging.go b/test/src/tests/generated/paging/paging.go index 31b44a918..52284558e 100644 --- a/test/src/tests/generated/paging/paging.go +++ b/test/src/tests/generated/paging/paging.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/to" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -35,6 +36,16 @@ func NewPagingClientWithBaseURI(baseURI string) PagingClient { // timeout - sets the maximum time that the server can spend processing the request, in seconds. The default is // 30 seconds. func (client PagingClient) GetMultiplePages(ctx context.Context, clientRequestID string, maxresults *int32, timeout *int32) (result ProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePages") + defer func() { + sc := -1 + if result.pr.Response.Response != nil { + sc = result.pr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getMultiplePagesNextResults req, err := client.GetMultiplePagesPreparer(ctx, clientRequestID, maxresults, timeout) if err != nil { @@ -102,8 +113,8 @@ func (client PagingClient) GetMultiplePagesResponder(resp *http.Response) (resul } // getMultiplePagesNextResults retrieves the next set of results, if any. -func (client PagingClient) getMultiplePagesNextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getMultiplePagesNextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getMultiplePagesNextResults", nil, "Failure preparing next results request") } @@ -124,12 +135,32 @@ func (client PagingClient) getMultiplePagesNextResults(lastResults ProductResult // GetMultiplePagesComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesComplete(ctx context.Context, clientRequestID string, maxresults *int32, timeout *int32) (result ProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePages") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetMultiplePages(ctx, clientRequestID, maxresults, timeout) return } // GetMultiplePagesFailure a paging operation that receives a 400 on the second call func (client PagingClient) GetMultiplePagesFailure(ctx context.Context) (result ProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesFailure") + defer func() { + sc := -1 + if result.pr.Response.Response != nil { + sc = result.pr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getMultiplePagesFailureNextResults req, err := client.GetMultiplePagesFailurePreparer(ctx) if err != nil { @@ -182,8 +213,8 @@ func (client PagingClient) GetMultiplePagesFailureResponder(resp *http.Response) } // getMultiplePagesFailureNextResults retrieves the next set of results, if any. -func (client PagingClient) getMultiplePagesFailureNextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getMultiplePagesFailureNextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getMultiplePagesFailureNextResults", nil, "Failure preparing next results request") } @@ -204,12 +235,32 @@ func (client PagingClient) getMultiplePagesFailureNextResults(lastResults Produc // GetMultiplePagesFailureComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesFailureComplete(ctx context.Context) (result ProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesFailure") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetMultiplePagesFailure(ctx) return } // GetMultiplePagesFailureURI a paging operation that receives an invalid nextLink func (client PagingClient) GetMultiplePagesFailureURI(ctx context.Context) (result ProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesFailureURI") + defer func() { + sc := -1 + if result.pr.Response.Response != nil { + sc = result.pr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getMultiplePagesFailureURINextResults req, err := client.GetMultiplePagesFailureURIPreparer(ctx) if err != nil { @@ -262,8 +313,8 @@ func (client PagingClient) GetMultiplePagesFailureURIResponder(resp *http.Respon } // getMultiplePagesFailureURINextResults retrieves the next set of results, if any. -func (client PagingClient) getMultiplePagesFailureURINextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getMultiplePagesFailureURINextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getMultiplePagesFailureURINextResults", nil, "Failure preparing next results request") } @@ -284,6 +335,16 @@ func (client PagingClient) getMultiplePagesFailureURINextResults(lastResults Pro // GetMultiplePagesFailureURIComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesFailureURIComplete(ctx context.Context) (result ProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesFailureURI") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetMultiplePagesFailureURI(ctx) return } @@ -293,7 +354,17 @@ func (client PagingClient) GetMultiplePagesFailureURIComplete(ctx context.Contex // APIVersion - sets the api version to use. // tenant - sets the tenant to use. func (client PagingClient) GetMultiplePagesFragmentNextLink(ctx context.Context, APIVersion string, tenant string) (result OdataProductResultPage, err error) { - result.fn = func(lastResult OdataProductResult) (OdataProductResult, error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesFragmentNextLink") + defer func() { + sc := -1 + if result.opr.Response.Response != nil { + sc = result.opr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = func(ctx context.Context, lastResult OdataProductResult) (OdataProductResult, error) { if lastResult.OdataNextLink == nil || len(to.String(lastResult.OdataNextLink)) < 1 { return OdataProductResult{}, nil } @@ -360,6 +431,16 @@ func (client PagingClient) GetMultiplePagesFragmentNextLinkResponder(resp *http. // GetMultiplePagesFragmentNextLinkComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesFragmentNextLinkComplete(ctx context.Context, APIVersion string, tenant string) (result OdataProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesFragmentNextLink") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetMultiplePagesFragmentNextLink(ctx, APIVersion, tenant) return } @@ -370,7 +451,17 @@ func (client PagingClient) GetMultiplePagesFragmentNextLinkComplete(ctx context. // APIVersion - sets the api version to use. // tenant - sets the tenant to use. func (client PagingClient) GetMultiplePagesFragmentWithGroupingNextLink(ctx context.Context, APIVersion string, tenant string) (result OdataProductResultPage, err error) { - result.fn = func(lastResult OdataProductResult) (OdataProductResult, error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesFragmentWithGroupingNextLink") + defer func() { + sc := -1 + if result.opr.Response.Response != nil { + sc = result.opr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = func(ctx context.Context, lastResult OdataProductResult) (OdataProductResult, error) { if lastResult.OdataNextLink == nil || len(to.String(lastResult.OdataNextLink)) < 1 { return OdataProductResult{}, nil } @@ -437,6 +528,16 @@ func (client PagingClient) GetMultiplePagesFragmentWithGroupingNextLinkResponder // GetMultiplePagesFragmentWithGroupingNextLinkComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesFragmentWithGroupingNextLinkComplete(ctx context.Context, APIVersion string, tenant string) (result OdataProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesFragmentWithGroupingNextLink") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetMultiplePagesFragmentWithGroupingNextLink(ctx, APIVersion, tenant) return } @@ -447,6 +548,16 @@ func (client PagingClient) GetMultiplePagesFragmentWithGroupingNextLinkComplete( // timeout - sets the maximum time that the server can spend processing the request, in seconds. The default is // 30 seconds. func (client PagingClient) GetMultiplePagesLRO(ctx context.Context, clientRequestID string, maxresults *int32, timeout *int32) (result PagingGetMultiplePagesLROFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesLRO") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetMultiplePagesLROPreparer(ctx, clientRequestID, maxresults, timeout) if err != nil { err = autorest.NewErrorWithError(err, "paginggroup.PagingClient", "GetMultiplePagesLRO", nil, "Failure preparing request") @@ -519,8 +630,8 @@ func (client PagingClient) getMultiplePagesLROResponder(resp *http.Response) (re } // getMultiplePagesLRONextResults retrieves the next set of results, if any. -func (client PagingClient) getMultiplePagesLRONextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getMultiplePagesLRONextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getMultiplePagesLRONextResults", nil, "Failure preparing next results request") } @@ -538,6 +649,16 @@ func (client PagingClient) getMultiplePagesLRONextResults(lastResults ProductRes // GetMultiplePagesLROComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesLROComplete(ctx context.Context, clientRequestID string, maxresults *int32, timeout *int32) (result PagingGetMultiplePagesLROAllFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesLRO") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } var future PagingGetMultiplePagesLROFuture future, err = client.GetMultiplePagesLRO(ctx, clientRequestID, maxresults, timeout) result.Future = future.Future @@ -547,6 +668,16 @@ func (client PagingClient) GetMultiplePagesLROComplete(ctx context.Context, clie // GetMultiplePagesRetryFirst a paging operation that fails on the first call with 500 and then retries and then get a // response including a nextLink that has 10 pages func (client PagingClient) GetMultiplePagesRetryFirst(ctx context.Context) (result ProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesRetryFirst") + defer func() { + sc := -1 + if result.pr.Response.Response != nil { + sc = result.pr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getMultiplePagesRetryFirstNextResults req, err := client.GetMultiplePagesRetryFirstPreparer(ctx) if err != nil { @@ -599,8 +730,8 @@ func (client PagingClient) GetMultiplePagesRetryFirstResponder(resp *http.Respon } // getMultiplePagesRetryFirstNextResults retrieves the next set of results, if any. -func (client PagingClient) getMultiplePagesRetryFirstNextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getMultiplePagesRetryFirstNextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getMultiplePagesRetryFirstNextResults", nil, "Failure preparing next results request") } @@ -621,6 +752,16 @@ func (client PagingClient) getMultiplePagesRetryFirstNextResults(lastResults Pro // GetMultiplePagesRetryFirstComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesRetryFirstComplete(ctx context.Context) (result ProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesRetryFirst") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetMultiplePagesRetryFirst(ctx) return } @@ -628,6 +769,16 @@ func (client PagingClient) GetMultiplePagesRetryFirstComplete(ctx context.Contex // GetMultiplePagesRetrySecond a paging operation that includes a nextLink that has 10 pages, of which the 2nd call // fails first with 500. The client should retry and finish all 10 pages eventually. func (client PagingClient) GetMultiplePagesRetrySecond(ctx context.Context) (result ProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesRetrySecond") + defer func() { + sc := -1 + if result.pr.Response.Response != nil { + sc = result.pr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getMultiplePagesRetrySecondNextResults req, err := client.GetMultiplePagesRetrySecondPreparer(ctx) if err != nil { @@ -680,8 +831,8 @@ func (client PagingClient) GetMultiplePagesRetrySecondResponder(resp *http.Respo } // getMultiplePagesRetrySecondNextResults retrieves the next set of results, if any. -func (client PagingClient) getMultiplePagesRetrySecondNextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getMultiplePagesRetrySecondNextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getMultiplePagesRetrySecondNextResults", nil, "Failure preparing next results request") } @@ -702,6 +853,16 @@ func (client PagingClient) getMultiplePagesRetrySecondNextResults(lastResults Pr // GetMultiplePagesRetrySecondComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesRetrySecondComplete(ctx context.Context) (result ProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesRetrySecond") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetMultiplePagesRetrySecond(ctx) return } @@ -713,6 +874,16 @@ func (client PagingClient) GetMultiplePagesRetrySecondComplete(ctx context.Conte // timeout - sets the maximum time that the server can spend processing the request, in seconds. The default is // 30 seconds. func (client PagingClient) GetMultiplePagesWithOffset(ctx context.Context, offset int32, clientRequestID string, maxresults *int32, timeout *int32) (result ProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesWithOffset") + defer func() { + sc := -1 + if result.pr.Response.Response != nil { + sc = result.pr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getMultiplePagesWithOffsetNextResults req, err := client.GetMultiplePagesWithOffsetPreparer(ctx, offset, clientRequestID, maxresults, timeout) if err != nil { @@ -784,8 +955,8 @@ func (client PagingClient) GetMultiplePagesWithOffsetResponder(resp *http.Respon } // getMultiplePagesWithOffsetNextResults retrieves the next set of results, if any. -func (client PagingClient) getMultiplePagesWithOffsetNextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getMultiplePagesWithOffsetNextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getMultiplePagesWithOffsetNextResults", nil, "Failure preparing next results request") } @@ -806,6 +977,16 @@ func (client PagingClient) getMultiplePagesWithOffsetNextResults(lastResults Pro // GetMultiplePagesWithOffsetComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetMultiplePagesWithOffsetComplete(ctx context.Context, offset int32, clientRequestID string, maxresults *int32, timeout *int32) (result ProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetMultiplePagesWithOffset") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetMultiplePagesWithOffset(ctx, offset, clientRequestID, maxresults, timeout) return } @@ -816,6 +997,16 @@ func (client PagingClient) GetMultiplePagesWithOffsetComplete(ctx context.Contex // timeout - sets the maximum time that the server can spend processing the request, in seconds. The default is // 30 seconds. func (client PagingClient) GetOdataMultiplePages(ctx context.Context, clientRequestID string, maxresults *int32, timeout *int32) (result OdataProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetOdataMultiplePages") + defer func() { + sc := -1 + if result.opr.Response.Response != nil { + sc = result.opr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getOdataMultiplePagesNextResults req, err := client.GetOdataMultiplePagesPreparer(ctx, clientRequestID, maxresults, timeout) if err != nil { @@ -883,8 +1074,8 @@ func (client PagingClient) GetOdataMultiplePagesResponder(resp *http.Response) ( } // getOdataMultiplePagesNextResults retrieves the next set of results, if any. -func (client PagingClient) getOdataMultiplePagesNextResults(lastResults OdataProductResult) (result OdataProductResult, err error) { - req, err := lastResults.odataProductResultPreparer() +func (client PagingClient) getOdataMultiplePagesNextResults(ctx context.Context, lastResults OdataProductResult) (result OdataProductResult, err error) { + req, err := lastResults.odataProductResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getOdataMultiplePagesNextResults", nil, "Failure preparing next results request") } @@ -905,12 +1096,32 @@ func (client PagingClient) getOdataMultiplePagesNextResults(lastResults OdataPro // GetOdataMultiplePagesComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetOdataMultiplePagesComplete(ctx context.Context, clientRequestID string, maxresults *int32, timeout *int32) (result OdataProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetOdataMultiplePages") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetOdataMultiplePages(ctx, clientRequestID, maxresults, timeout) return } // GetSinglePages a paging operation that finishes on the first call without a nextlink func (client PagingClient) GetSinglePages(ctx context.Context) (result ProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetSinglePages") + defer func() { + sc := -1 + if result.pr.Response.Response != nil { + sc = result.pr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getSinglePagesNextResults req, err := client.GetSinglePagesPreparer(ctx) if err != nil { @@ -963,8 +1174,8 @@ func (client PagingClient) GetSinglePagesResponder(resp *http.Response) (result } // getSinglePagesNextResults retrieves the next set of results, if any. -func (client PagingClient) getSinglePagesNextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getSinglePagesNextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getSinglePagesNextResults", nil, "Failure preparing next results request") } @@ -985,12 +1196,32 @@ func (client PagingClient) getSinglePagesNextResults(lastResults ProductResult) // GetSinglePagesComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetSinglePagesComplete(ctx context.Context) (result ProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetSinglePages") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetSinglePages(ctx) return } // GetSinglePagesFailure a paging operation that receives a 400 on the first call func (client PagingClient) GetSinglePagesFailure(ctx context.Context) (result ProductResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetSinglePagesFailure") + defer func() { + sc := -1 + if result.pr.Response.Response != nil { + sc = result.pr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.fn = client.getSinglePagesFailureNextResults req, err := client.GetSinglePagesFailurePreparer(ctx) if err != nil { @@ -1043,8 +1274,8 @@ func (client PagingClient) GetSinglePagesFailureResponder(resp *http.Response) ( } // getSinglePagesFailureNextResults retrieves the next set of results, if any. -func (client PagingClient) getSinglePagesFailureNextResults(lastResults ProductResult) (result ProductResult, err error) { - req, err := lastResults.productResultPreparer() +func (client PagingClient) getSinglePagesFailureNextResults(ctx context.Context, lastResults ProductResult) (result ProductResult, err error) { + req, err := lastResults.productResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "paginggroup.PagingClient", "getSinglePagesFailureNextResults", nil, "Failure preparing next results request") } @@ -1065,6 +1296,16 @@ func (client PagingClient) getSinglePagesFailureNextResults(lastResults ProductR // GetSinglePagesFailureComplete enumerates all values, automatically crossing page boundaries as required. func (client PagingClient) GetSinglePagesFailureComplete(ctx context.Context) (result ProductResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.GetSinglePagesFailure") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } result.page, err = client.GetSinglePagesFailure(ctx) return } @@ -1075,6 +1316,16 @@ func (client PagingClient) GetSinglePagesFailureComplete(ctx context.Context) (r // tenant - sets the tenant to use. // nextLink - next link for list operation. func (client PagingClient) NextFragment(ctx context.Context, APIVersion string, tenant string, nextLink string) (result OdataProductResult, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.NextFragment") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.NextFragmentPreparer(ctx, APIVersion, tenant, nextLink) if err != nil { err = autorest.NewErrorWithError(err, "paginggroup.PagingClient", "NextFragment", nil, "Failure preparing request") @@ -1141,6 +1392,16 @@ func (client PagingClient) NextFragmentResponder(resp *http.Response) (result Od // tenant - sets the tenant to use. // nextLink - next link for list operation. func (client PagingClient) NextFragmentWithGrouping(ctx context.Context, APIVersion string, tenant string, nextLink string) (result OdataProductResult, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PagingClient.NextFragmentWithGrouping") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.NextFragmentWithGroupingPreparer(ctx, APIVersion, tenant, nextLink) if err != nil { err = autorest.NewErrorWithError(err, "paginggroup.PagingClient", "NextFragmentWithGrouping", nil, "Failure preparing request") diff --git a/test/src/tests/generated/report/client.go b/test/src/tests/generated/report/client.go index 649d83b40..7fa0dd655 100644 --- a/test/src/tests/generated/report/client.go +++ b/test/src/tests/generated/report/client.go @@ -13,6 +13,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -45,6 +46,16 @@ func NewWithBaseURI(baseURI string) BaseClient { // qualifier - if specified, qualifies the generated report further (e.g. '2.7' vs '3.5' in for Python). The // only effect is, that generators that run all tests several times, can distinguish the generated reports. func (client BaseClient) GetReport(ctx context.Context, qualifier string) (result SetInt32, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetReport") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetReportPreparer(ctx, qualifier) if err != nil { err = autorest.NewErrorWithError(err, "report.BaseClient", "GetReport", nil, "Failure preparing request") diff --git a/test/src/tests/generated/report/models.go b/test/src/tests/generated/report/models.go index 4517f55a1..0fa47b682 100644 --- a/test/src/tests/generated/report/models.go +++ b/test/src/tests/generated/report/models.go @@ -11,6 +11,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/report" + // Error ... type Error struct { Status *int32 `json:"status,omitempty"` diff --git a/test/src/tests/generated/required-optional/explicit.go b/test/src/tests/generated/required-optional/explicit.go index cc70f6143..0db2dbbc7 100644 --- a/test/src/tests/generated/required-optional/explicit.go +++ b/test/src/tests/generated/required-optional/explicit.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -31,6 +32,16 @@ func NewExplicitClientWithBaseURI(baseURI string, requiredGlobalPath string, req // PostOptionalArrayHeader test explicitly optional integer. Please put a header 'headerParameter' => null. func (client ExplicitClient) PostOptionalArrayHeader(ctx context.Context, headerParameter []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalArrayHeader") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalArrayHeaderPreparer(ctx, headerParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalArrayHeader", nil, "Failure preparing request") @@ -86,6 +97,16 @@ func (client ExplicitClient) PostOptionalArrayHeaderResponder(resp *http.Respons // PostOptionalArrayParameter test explicitly optional array. Please put null. func (client ExplicitClient) PostOptionalArrayParameter(ctx context.Context, bodyParameter []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalArrayParameter") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalArrayParameterPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalArrayParameter", nil, "Failure preparing request") @@ -142,6 +163,16 @@ func (client ExplicitClient) PostOptionalArrayParameterResponder(resp *http.Resp // PostOptionalArrayProperty test explicitly optional array. Please put a valid array-wrapper with 'value' = null. func (client ExplicitClient) PostOptionalArrayProperty(ctx context.Context, bodyParameter *ArrayOptionalWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalArrayProperty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalArrayPropertyPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalArrayProperty", nil, "Failure preparing request") @@ -198,6 +229,16 @@ func (client ExplicitClient) PostOptionalArrayPropertyResponder(resp *http.Respo // PostOptionalClassParameter test explicitly optional complex object. Please put null. func (client ExplicitClient) PostOptionalClassParameter(ctx context.Context, bodyParameter *Product) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalClassParameter") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bodyParameter, Constraints: []validation.Constraint{{Target: "bodyParameter", Name: validation.Null, Rule: false, @@ -262,6 +303,16 @@ func (client ExplicitClient) PostOptionalClassParameterResponder(resp *http.Resp // PostOptionalClassProperty test explicitly optional complex object. Please put a valid class-wrapper with 'value' = // null. func (client ExplicitClient) PostOptionalClassProperty(ctx context.Context, bodyParameter *ClassOptionalWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalClassProperty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bodyParameter, Constraints: []validation.Constraint{{Target: "bodyParameter", Name: validation.Null, Rule: false, @@ -327,6 +378,16 @@ func (client ExplicitClient) PostOptionalClassPropertyResponder(resp *http.Respo // PostOptionalIntegerHeader test explicitly optional integer. Please put a header 'headerParameter' => null. func (client ExplicitClient) PostOptionalIntegerHeader(ctx context.Context, headerParameter *int32) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalIntegerHeader") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalIntegerHeaderPreparer(ctx, headerParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalIntegerHeader", nil, "Failure preparing request") @@ -382,6 +443,16 @@ func (client ExplicitClient) PostOptionalIntegerHeaderResponder(resp *http.Respo // PostOptionalIntegerParameter test explicitly optional integer. Please put null. func (client ExplicitClient) PostOptionalIntegerParameter(ctx context.Context, bodyParameter *int32) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalIntegerParameter") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalIntegerParameterPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalIntegerParameter", nil, "Failure preparing request") @@ -438,6 +509,16 @@ func (client ExplicitClient) PostOptionalIntegerParameterResponder(resp *http.Re // PostOptionalIntegerProperty test explicitly optional integer. Please put a valid int-wrapper with 'value' = null. func (client ExplicitClient) PostOptionalIntegerProperty(ctx context.Context, bodyParameter *IntOptionalWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalIntegerProperty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalIntegerPropertyPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalIntegerProperty", nil, "Failure preparing request") @@ -494,6 +575,16 @@ func (client ExplicitClient) PostOptionalIntegerPropertyResponder(resp *http.Res // PostOptionalStringHeader test explicitly optional string. Please put a header 'headerParameter' => null. func (client ExplicitClient) PostOptionalStringHeader(ctx context.Context, bodyParameter string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalStringHeader") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalStringHeaderPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalStringHeader", nil, "Failure preparing request") @@ -549,6 +640,16 @@ func (client ExplicitClient) PostOptionalStringHeaderResponder(resp *http.Respon // PostOptionalStringParameter test explicitly optional string. Please put null. func (client ExplicitClient) PostOptionalStringParameter(ctx context.Context, bodyParameter string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalStringParameter") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalStringParameterPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalStringParameter", nil, "Failure preparing request") @@ -605,6 +706,16 @@ func (client ExplicitClient) PostOptionalStringParameterResponder(resp *http.Res // PostOptionalStringProperty test explicitly optional integer. Please put a valid string-wrapper with 'value' = null. func (client ExplicitClient) PostOptionalStringProperty(ctx context.Context, bodyParameter *StringOptionalWrapper) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostOptionalStringProperty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostOptionalStringPropertyPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostOptionalStringProperty", nil, "Failure preparing request") @@ -662,6 +773,16 @@ func (client ExplicitClient) PostOptionalStringPropertyResponder(resp *http.Resp // PostRequiredArrayHeader test explicitly required array. Please put a header 'headerParameter' => null and the client // library should throw before the request is sent. func (client ExplicitClient) PostRequiredArrayHeader(ctx context.Context, headerParameter []string) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredArrayHeader") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: headerParameter, Constraints: []validation.Constraint{{Target: "headerParameter", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -722,6 +843,16 @@ func (client ExplicitClient) PostRequiredArrayHeaderResponder(resp *http.Respons // PostRequiredArrayParameter test explicitly required array. Please put null and the client library should throw // before the request is sent. func (client ExplicitClient) PostRequiredArrayParameter(ctx context.Context, bodyParameter []string) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredArrayParameter") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bodyParameter, Constraints: []validation.Constraint{{Target: "bodyParameter", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -783,6 +914,16 @@ func (client ExplicitClient) PostRequiredArrayParameterResponder(resp *http.Resp // PostRequiredArrayProperty test explicitly required array. Please put a valid array-wrapper with 'value' = null and // the client library should throw before the request is sent. func (client ExplicitClient) PostRequiredArrayProperty(ctx context.Context, bodyParameter ArrayWrapper) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredArrayProperty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bodyParameter, Constraints: []validation.Constraint{{Target: "bodyParameter.Value", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -844,6 +985,16 @@ func (client ExplicitClient) PostRequiredArrayPropertyResponder(resp *http.Respo // PostRequiredClassParameter test explicitly required complex object. Please put null and the client library should // throw before the request is sent. func (client ExplicitClient) PostRequiredClassParameter(ctx context.Context, bodyParameter Product) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredClassParameter") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bodyParameter, Constraints: []validation.Constraint{{Target: "bodyParameter.ID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -905,6 +1056,16 @@ func (client ExplicitClient) PostRequiredClassParameterResponder(resp *http.Resp // PostRequiredClassProperty test explicitly required complex object. Please put a valid class-wrapper with 'value' = // null and the client library should throw before the request is sent. func (client ExplicitClient) PostRequiredClassProperty(ctx context.Context, bodyParameter ClassWrapper) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredClassProperty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bodyParameter, Constraints: []validation.Constraint{{Target: "bodyParameter.Value", Name: validation.Null, Rule: true, @@ -967,6 +1128,16 @@ func (client ExplicitClient) PostRequiredClassPropertyResponder(resp *http.Respo // PostRequiredIntegerHeader test explicitly required integer. Please put a header 'headerParameter' => null and the // client library should throw before the request is sent. func (client ExplicitClient) PostRequiredIntegerHeader(ctx context.Context, headerParameter int32) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredIntegerHeader") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostRequiredIntegerHeaderPreparer(ctx, headerParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostRequiredIntegerHeader", nil, "Failure preparing request") @@ -1021,6 +1192,16 @@ func (client ExplicitClient) PostRequiredIntegerHeaderResponder(resp *http.Respo // PostRequiredIntegerParameter test explicitly required integer. Please put null and the client library should throw // before the request is sent. func (client ExplicitClient) PostRequiredIntegerParameter(ctx context.Context, bodyParameter int32) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredIntegerParameter") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostRequiredIntegerParameterPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostRequiredIntegerParameter", nil, "Failure preparing request") @@ -1076,6 +1257,16 @@ func (client ExplicitClient) PostRequiredIntegerParameterResponder(resp *http.Re // PostRequiredIntegerProperty test explicitly required integer. Please put a valid int-wrapper with 'value' = null and // the client library should throw before the request is sent. func (client ExplicitClient) PostRequiredIntegerProperty(ctx context.Context, bodyParameter IntWrapper) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredIntegerProperty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bodyParameter, Constraints: []validation.Constraint{{Target: "bodyParameter.Value", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -1137,6 +1328,16 @@ func (client ExplicitClient) PostRequiredIntegerPropertyResponder(resp *http.Res // PostRequiredStringHeader test explicitly required string. Please put a header 'headerParameter' => null and the // client library should throw before the request is sent. func (client ExplicitClient) PostRequiredStringHeader(ctx context.Context, headerParameter string) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredStringHeader") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostRequiredStringHeaderPreparer(ctx, headerParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostRequiredStringHeader", nil, "Failure preparing request") @@ -1191,6 +1392,16 @@ func (client ExplicitClient) PostRequiredStringHeaderResponder(resp *http.Respon // PostRequiredStringParameter test explicitly required string. Please put null and the client library should throw // before the request is sent. func (client ExplicitClient) PostRequiredStringParameter(ctx context.Context, bodyParameter string) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredStringParameter") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PostRequiredStringParameterPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ExplicitClient", "PostRequiredStringParameter", nil, "Failure preparing request") @@ -1246,6 +1457,16 @@ func (client ExplicitClient) PostRequiredStringParameterResponder(resp *http.Res // PostRequiredStringProperty test explicitly required string. Please put a valid string-wrapper with 'value' = null // and the client library should throw before the request is sent. func (client ExplicitClient) PostRequiredStringProperty(ctx context.Context, bodyParameter StringWrapper) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExplicitClient.PostRequiredStringProperty") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bodyParameter, Constraints: []validation.Constraint{{Target: "bodyParameter.Value", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { diff --git a/test/src/tests/generated/required-optional/implicit.go b/test/src/tests/generated/required-optional/implicit.go index 40bfce716..eb12fc3d6 100644 --- a/test/src/tests/generated/required-optional/implicit.go +++ b/test/src/tests/generated/required-optional/implicit.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -30,6 +31,16 @@ func NewImplicitClientWithBaseURI(baseURI string, requiredGlobalPath string, req // GetOptionalGlobalQuery test implicitly optional query parameter func (client ImplicitClient) GetOptionalGlobalQuery(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ImplicitClient.GetOptionalGlobalQuery") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetOptionalGlobalQueryPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ImplicitClient", "GetOptionalGlobalQuery", nil, "Failure preparing request") @@ -88,6 +99,16 @@ func (client ImplicitClient) GetOptionalGlobalQueryResponder(resp *http.Response // GetRequiredGlobalPath test implicitly required path parameter func (client ImplicitClient) GetRequiredGlobalPath(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ImplicitClient.GetRequiredGlobalPath") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetRequiredGlobalPathPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ImplicitClient", "GetRequiredGlobalPath", nil, "Failure preparing request") @@ -144,6 +165,16 @@ func (client ImplicitClient) GetRequiredGlobalPathResponder(resp *http.Response) // GetRequiredGlobalQuery test implicitly required query parameter func (client ImplicitClient) GetRequiredGlobalQuery(ctx context.Context) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ImplicitClient.GetRequiredGlobalQuery") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetRequiredGlobalQueryPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ImplicitClient", "GetRequiredGlobalQuery", nil, "Failure preparing request") @@ -201,6 +232,16 @@ func (client ImplicitClient) GetRequiredGlobalQueryResponder(resp *http.Response // GetRequiredPath test implicitly required path parameter func (client ImplicitClient) GetRequiredPath(ctx context.Context, pathParameter string) (result Error, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ImplicitClient.GetRequiredPath") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetRequiredPathPreparer(ctx, pathParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ImplicitClient", "GetRequiredPath", nil, "Failure preparing request") @@ -257,6 +298,16 @@ func (client ImplicitClient) GetRequiredPathResponder(resp *http.Response) (resu // PutOptionalBody test implicitly optional body parameter func (client ImplicitClient) PutOptionalBody(ctx context.Context, bodyParameter string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ImplicitClient.PutOptionalBody") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutOptionalBodyPreparer(ctx, bodyParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ImplicitClient", "PutOptionalBody", nil, "Failure preparing request") @@ -313,6 +364,16 @@ func (client ImplicitClient) PutOptionalBodyResponder(resp *http.Response) (resu // PutOptionalHeader test implicitly optional header parameter func (client ImplicitClient) PutOptionalHeader(ctx context.Context, queryParameter string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ImplicitClient.PutOptionalHeader") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutOptionalHeaderPreparer(ctx, queryParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ImplicitClient", "PutOptionalHeader", nil, "Failure preparing request") @@ -368,6 +429,16 @@ func (client ImplicitClient) PutOptionalHeaderResponder(resp *http.Response) (re // PutOptionalQuery test implicitly optional query parameter func (client ImplicitClient) PutOptionalQuery(ctx context.Context, queryParameter string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ImplicitClient.PutOptionalQuery") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.PutOptionalQueryPreparer(ctx, queryParameter) if err != nil { err = autorest.NewErrorWithError(err, "optionalgroup.ImplicitClient", "PutOptionalQuery", nil, "Failure preparing request") diff --git a/test/src/tests/generated/required-optional/models.go b/test/src/tests/generated/required-optional/models.go index 887201d2f..c88066895 100644 --- a/test/src/tests/generated/required-optional/models.go +++ b/test/src/tests/generated/required-optional/models.go @@ -10,6 +10,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/required-optional" + // ArrayOptionalWrapper ... type ArrayOptionalWrapper struct { Value *[]string `json:"value,omitempty"` diff --git a/test/src/tests/generated/url/models.go b/test/src/tests/generated/url/models.go index b9800c210..a9993602c 100644 --- a/test/src/tests/generated/url/models.go +++ b/test/src/tests/generated/url/models.go @@ -6,6 +6,9 @@ package urlgroup // Code generated by Microsoft (R) AutoRest Code Generator. // Changes may cause incorrect behavior and will be lost if the code is regenerated. +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/url" + // URIColor enumerates the values for uri color. type URIColor string diff --git a/test/src/tests/generated/url/pathitems.go b/test/src/tests/generated/url/pathitems.go index c346db55b..5eedd625d 100644 --- a/test/src/tests/generated/url/pathitems.go +++ b/test/src/tests/generated/url/pathitems.go @@ -10,6 +10,7 @@ import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -37,6 +38,16 @@ func NewPathItemsClientWithBaseURI(baseURI string, globalStringPath string, glob // localStringQuery - should contain value 'localStringQuery' // pathItemStringQuery - a string value 'pathItemStringQuery' that appears as a query parameter func (client PathItemsClient) GetAllWithValues(ctx context.Context, localStringPath string, pathItemStringPath string, localStringQuery string, pathItemStringQuery string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathItemsClient.GetAllWithValues") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetAllWithValuesPreparer(ctx, localStringPath, pathItemStringPath, localStringQuery, pathItemStringQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathItemsClient", "GetAllWithValues", nil, "Failure preparing request") @@ -113,6 +124,16 @@ func (client PathItemsClient) GetAllWithValuesResponder(resp *http.Response) (re // localStringQuery - should contain null value // pathItemStringQuery - a string value 'pathItemStringQuery' that appears as a query parameter func (client PathItemsClient) GetGlobalAndLocalQueryNull(ctx context.Context, localStringPath string, pathItemStringPath string, localStringQuery string, pathItemStringQuery string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathItemsClient.GetGlobalAndLocalQueryNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetGlobalAndLocalQueryNullPreparer(ctx, localStringPath, pathItemStringPath, localStringQuery, pathItemStringQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathItemsClient", "GetGlobalAndLocalQueryNull", nil, "Failure preparing request") @@ -189,6 +210,16 @@ func (client PathItemsClient) GetGlobalAndLocalQueryNullResponder(resp *http.Res // localStringQuery - should contain value 'localStringQuery' // pathItemStringQuery - a string value 'pathItemStringQuery' that appears as a query parameter func (client PathItemsClient) GetGlobalQueryNull(ctx context.Context, localStringPath string, pathItemStringPath string, localStringQuery string, pathItemStringQuery string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathItemsClient.GetGlobalQueryNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetGlobalQueryNullPreparer(ctx, localStringPath, pathItemStringPath, localStringQuery, pathItemStringQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathItemsClient", "GetGlobalQueryNull", nil, "Failure preparing request") @@ -265,6 +296,16 @@ func (client PathItemsClient) GetGlobalQueryNullResponder(resp *http.Response) ( // localStringQuery - should contain value null // pathItemStringQuery - should contain value null func (client PathItemsClient) GetLocalPathItemQueryNull(ctx context.Context, localStringPath string, pathItemStringPath string, localStringQuery string, pathItemStringQuery string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathItemsClient.GetLocalPathItemQueryNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLocalPathItemQueryNullPreparer(ctx, localStringPath, pathItemStringPath, localStringQuery, pathItemStringQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathItemsClient", "GetLocalPathItemQueryNull", nil, "Failure preparing request") diff --git a/test/src/tests/generated/url/paths.go b/test/src/tests/generated/url/paths.go index ae8ddab1d..185f3fe0a 100644 --- a/test/src/tests/generated/url/paths.go +++ b/test/src/tests/generated/url/paths.go @@ -12,6 +12,7 @@ import ( "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -36,6 +37,16 @@ func NewPathsClientWithBaseURI(baseURI string, globalStringPath string, globalSt // arrayPath - an array of string ['ArrayPath1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the csv-array // format func (client PathsClient) ArrayCsvInPath(ctx context.Context, arrayPath []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.ArrayCsvInPath") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: arrayPath, Constraints: []validation.Constraint{{Target: "arrayPath", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -99,6 +110,16 @@ func (client PathsClient) ArrayCsvInPathResponder(resp *http.Response) (result a // Parameters: // base64URLPath - base64url encoded value func (client PathsClient) Base64URL(ctx context.Context, base64URLPath string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.Base64URL") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.Base64URLPreparer(ctx, base64URLPath) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "Base64URL", nil, "Failure preparing request") @@ -154,6 +175,16 @@ func (client PathsClient) Base64URLResponder(resp *http.Response) (result autore // ByteEmpty get '' as byte array func (client PathsClient) ByteEmpty(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.ByteEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ByteEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "ByteEmpty", nil, "Failure preparing request") @@ -211,6 +242,16 @@ func (client PathsClient) ByteEmptyResponder(resp *http.Response) (result autore // Parameters: // bytePath - '啊齄丂狛狜隣郎隣兀﨩' multibyte value as utf-8 encoded byte array func (client PathsClient) ByteMultiByte(ctx context.Context, bytePath []byte) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.ByteMultiByte") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bytePath, Constraints: []validation.Constraint{{Target: "bytePath", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -274,6 +315,16 @@ func (client PathsClient) ByteMultiByteResponder(resp *http.Response) (result au // Parameters: // bytePath - null as byte array (should throw) func (client PathsClient) ByteNull(ctx context.Context, bytePath []byte) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.ByteNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: bytePath, Constraints: []validation.Constraint{{Target: "bytePath", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { @@ -337,6 +388,16 @@ func (client PathsClient) ByteNullResponder(resp *http.Response) (result autores // Parameters: // datePath - null as date (should throw) func (client PathsClient) DateNull(ctx context.Context, datePath date.Date) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.DateNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DateNullPreparer(ctx, datePath) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "DateNull", nil, "Failure preparing request") @@ -394,6 +455,16 @@ func (client PathsClient) DateNullResponder(resp *http.Response) (result autores // Parameters: // dateTimePath - null as date-time func (client PathsClient) DateTimeNull(ctx context.Context, dateTimePath date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.DateTimeNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DateTimeNullPreparer(ctx, dateTimePath) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "DateTimeNull", nil, "Failure preparing request") @@ -449,6 +520,16 @@ func (client PathsClient) DateTimeNullResponder(resp *http.Response) (result aut // DateTimeValid get '2012-01-01T01:01:01Z' as date-time func (client PathsClient) DateTimeValid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.DateTimeValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DateTimeValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "DateTimeValid", nil, "Failure preparing request") @@ -504,6 +585,16 @@ func (client PathsClient) DateTimeValidResponder(resp *http.Response) (result au // DateValid get '2012-01-01' as date func (client PathsClient) DateValid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.DateValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DateValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "DateValid", nil, "Failure preparing request") @@ -559,6 +650,16 @@ func (client PathsClient) DateValidResponder(resp *http.Response) (result autore // DoubleDecimalNegative get '-9999999.999' numeric value func (client PathsClient) DoubleDecimalNegative(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.DoubleDecimalNegative") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DoubleDecimalNegativePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "DoubleDecimalNegative", nil, "Failure preparing request") @@ -614,6 +715,16 @@ func (client PathsClient) DoubleDecimalNegativeResponder(resp *http.Response) (r // DoubleDecimalPositive get '9999999.999' numeric value func (client PathsClient) DoubleDecimalPositive(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.DoubleDecimalPositive") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DoubleDecimalPositivePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "DoubleDecimalPositive", nil, "Failure preparing request") @@ -671,6 +782,16 @@ func (client PathsClient) DoubleDecimalPositiveResponder(resp *http.Response) (r // Parameters: // enumPath - send null should throw func (client PathsClient) EnumNull(ctx context.Context, enumPath URIColor) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.EnumNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.EnumNullPreparer(ctx, enumPath) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "EnumNull", nil, "Failure preparing request") @@ -728,6 +849,16 @@ func (client PathsClient) EnumNullResponder(resp *http.Response) (result autores // Parameters: // enumPath - send the value green func (client PathsClient) EnumValid(ctx context.Context, enumPath URIColor) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.EnumValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.EnumValidPreparer(ctx, enumPath) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "EnumValid", nil, "Failure preparing request") @@ -783,6 +914,16 @@ func (client PathsClient) EnumValidResponder(resp *http.Response) (result autore // FloatScientificNegative get '-1.034E-20' numeric value func (client PathsClient) FloatScientificNegative(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.FloatScientificNegative") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.FloatScientificNegativePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "FloatScientificNegative", nil, "Failure preparing request") @@ -838,6 +979,16 @@ func (client PathsClient) FloatScientificNegativeResponder(resp *http.Response) // FloatScientificPositive get '1.034E+20' numeric value func (client PathsClient) FloatScientificPositive(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.FloatScientificPositive") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.FloatScientificPositivePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "FloatScientificPositive", nil, "Failure preparing request") @@ -893,6 +1044,16 @@ func (client PathsClient) FloatScientificPositiveResponder(resp *http.Response) // GetBooleanFalse get false Boolean value on path func (client PathsClient) GetBooleanFalse(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.GetBooleanFalse") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanFalsePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "GetBooleanFalse", nil, "Failure preparing request") @@ -948,6 +1109,16 @@ func (client PathsClient) GetBooleanFalseResponder(resp *http.Response) (result // GetBooleanTrue get true Boolean value on path func (client PathsClient) GetBooleanTrue(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.GetBooleanTrue") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanTruePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "GetBooleanTrue", nil, "Failure preparing request") @@ -1003,6 +1174,16 @@ func (client PathsClient) GetBooleanTrueResponder(resp *http.Response) (result a // GetIntNegativeOneMillion get '-1000000' integer value func (client PathsClient) GetIntNegativeOneMillion(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.GetIntNegativeOneMillion") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntNegativeOneMillionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "GetIntNegativeOneMillion", nil, "Failure preparing request") @@ -1058,6 +1239,16 @@ func (client PathsClient) GetIntNegativeOneMillionResponder(resp *http.Response) // GetIntOneMillion get '1000000' integer value func (client PathsClient) GetIntOneMillion(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.GetIntOneMillion") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntOneMillionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "GetIntOneMillion", nil, "Failure preparing request") @@ -1113,6 +1304,16 @@ func (client PathsClient) GetIntOneMillionResponder(resp *http.Response) (result // GetNegativeTenBillion get '-10000000000' 64 bit integer value func (client PathsClient) GetNegativeTenBillion(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.GetNegativeTenBillion") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNegativeTenBillionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "GetNegativeTenBillion", nil, "Failure preparing request") @@ -1168,6 +1369,16 @@ func (client PathsClient) GetNegativeTenBillionResponder(resp *http.Response) (r // GetTenBillion get '10000000000' 64 bit integer value func (client PathsClient) GetTenBillion(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.GetTenBillion") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetTenBillionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "GetTenBillion", nil, "Failure preparing request") @@ -1223,6 +1434,16 @@ func (client PathsClient) GetTenBillionResponder(resp *http.Response) (result au // StringEmpty get '' func (client PathsClient) StringEmpty(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.StringEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.StringEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "StringEmpty", nil, "Failure preparing request") @@ -1280,6 +1501,16 @@ func (client PathsClient) StringEmptyResponder(resp *http.Response) (result auto // Parameters: // stringPath - null string value func (client PathsClient) StringNull(ctx context.Context, stringPath string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.StringNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.StringNullPreparer(ctx, stringPath) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "StringNull", nil, "Failure preparing request") @@ -1335,6 +1566,16 @@ func (client PathsClient) StringNullResponder(resp *http.Response) (result autor // StringUnicode get '啊齄丂狛狜隣郎隣兀﨩' multi-byte string value func (client PathsClient) StringUnicode(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.StringUnicode") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.StringUnicodePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "StringUnicode", nil, "Failure preparing request") @@ -1390,6 +1631,16 @@ func (client PathsClient) StringUnicodeResponder(resp *http.Response) (result au // StringURLEncoded get 'begin!*'();:@ &=+$,/?#[]end func (client PathsClient) StringURLEncoded(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.StringURLEncoded") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.StringURLEncodedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "StringURLEncoded", nil, "Failure preparing request") @@ -1447,6 +1698,16 @@ func (client PathsClient) StringURLEncodedResponder(resp *http.Response) (result // Parameters: // unixTimeURLPath - unix time encoded value func (client PathsClient) UnixTimeURL(ctx context.Context, unixTimeURLPath date.UnixTime) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PathsClient.UnixTimeURL") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.UnixTimeURLPreparer(ctx, unixTimeURLPath) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.PathsClient", "UnixTimeURL", nil, "Failure preparing request") diff --git a/test/src/tests/generated/url/queries.go b/test/src/tests/generated/url/queries.go index 84ef0ac54..c3e6887be 100644 --- a/test/src/tests/generated/url/queries.go +++ b/test/src/tests/generated/url/queries.go @@ -11,6 +11,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/date" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -33,6 +34,16 @@ func NewQueriesClientWithBaseURI(baseURI string, globalStringPath string, global // Parameters: // arrayQuery - an empty array [] of string using the csv-array format func (client QueriesClient) ArrayStringCsvEmpty(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringCsvEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ArrayStringCsvEmptyPreparer(ctx, arrayQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvEmpty", nil, "Failure preparing request") @@ -92,6 +103,16 @@ func (client QueriesClient) ArrayStringCsvEmptyResponder(resp *http.Response) (r // Parameters: // arrayQuery - a null array of string using the csv-array format func (client QueriesClient) ArrayStringCsvNull(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringCsvNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ArrayStringCsvNullPreparer(ctx, arrayQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvNull", nil, "Failure preparing request") @@ -153,6 +174,16 @@ func (client QueriesClient) ArrayStringCsvNullResponder(resp *http.Response) (re // arrayQuery - an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the // csv-array format func (client QueriesClient) ArrayStringCsvValid(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringCsvValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ArrayStringCsvValidPreparer(ctx, arrayQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvValid", nil, "Failure preparing request") @@ -214,6 +245,16 @@ func (client QueriesClient) ArrayStringCsvValidResponder(resp *http.Response) (r // arrayQuery - an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the // pipes-array format func (client QueriesClient) ArrayStringPipesValid(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringPipesValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ArrayStringPipesValidPreparer(ctx, arrayQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringPipesValid", nil, "Failure preparing request") @@ -275,6 +316,16 @@ func (client QueriesClient) ArrayStringPipesValidResponder(resp *http.Response) // arrayQuery - an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the // ssv-array format func (client QueriesClient) ArrayStringSsvValid(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringSsvValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ArrayStringSsvValidPreparer(ctx, arrayQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringSsvValid", nil, "Failure preparing request") @@ -336,6 +387,16 @@ func (client QueriesClient) ArrayStringSsvValidResponder(resp *http.Response) (r // arrayQuery - an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the // tsv-array format func (client QueriesClient) ArrayStringTsvValid(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringTsvValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ArrayStringTsvValidPreparer(ctx, arrayQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringTsvValid", nil, "Failure preparing request") @@ -393,6 +454,16 @@ func (client QueriesClient) ArrayStringTsvValidResponder(resp *http.Response) (r // ByteEmpty get '' as byte array func (client QueriesClient) ByteEmpty(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ByteEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ByteEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteEmpty", nil, "Failure preparing request") @@ -451,6 +522,16 @@ func (client QueriesClient) ByteEmptyResponder(resp *http.Response) (result auto // Parameters: // byteQuery - '啊齄丂狛狜隣郎隣兀﨩' multibyte value as utf-8 encoded byte array func (client QueriesClient) ByteMultiByte(ctx context.Context, byteQuery []byte) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ByteMultiByte") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ByteMultiBytePreparer(ctx, byteQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteMultiByte", nil, "Failure preparing request") @@ -510,6 +591,16 @@ func (client QueriesClient) ByteMultiByteResponder(resp *http.Response) (result // Parameters: // byteQuery - null as byte array (no query parameters in uri) func (client QueriesClient) ByteNull(ctx context.Context, byteQuery []byte) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ByteNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.ByteNullPreparer(ctx, byteQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteNull", nil, "Failure preparing request") @@ -569,6 +660,16 @@ func (client QueriesClient) ByteNullResponder(resp *http.Response) (result autor // Parameters: // dateQuery - null as date (no query parameters in uri) func (client QueriesClient) DateNull(ctx context.Context, dateQuery *date.Date) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DateNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DateNullPreparer(ctx, dateQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateNull", nil, "Failure preparing request") @@ -628,6 +729,16 @@ func (client QueriesClient) DateNullResponder(resp *http.Response) (result autor // Parameters: // dateTimeQuery - null as date-time (no query parameters) func (client QueriesClient) DateTimeNull(ctx context.Context, dateTimeQuery *date.Time) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DateTimeNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DateTimeNullPreparer(ctx, dateTimeQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateTimeNull", nil, "Failure preparing request") @@ -685,6 +796,16 @@ func (client QueriesClient) DateTimeNullResponder(resp *http.Response) (result a // DateTimeValid get '2012-01-01T01:01:01Z' as date-time func (client QueriesClient) DateTimeValid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DateTimeValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DateTimeValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateTimeValid", nil, "Failure preparing request") @@ -741,6 +862,16 @@ func (client QueriesClient) DateTimeValidResponder(resp *http.Response) (result // DateValid get '2012-01-01' as date func (client QueriesClient) DateValid(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DateValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DateValidPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateValid", nil, "Failure preparing request") @@ -797,6 +928,16 @@ func (client QueriesClient) DateValidResponder(resp *http.Response) (result auto // DoubleDecimalNegative get '-9999999.999' numeric value func (client QueriesClient) DoubleDecimalNegative(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DoubleDecimalNegative") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DoubleDecimalNegativePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleDecimalNegative", nil, "Failure preparing request") @@ -853,6 +994,16 @@ func (client QueriesClient) DoubleDecimalNegativeResponder(resp *http.Response) // DoubleDecimalPositive get '9999999.999' numeric value func (client QueriesClient) DoubleDecimalPositive(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DoubleDecimalPositive") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DoubleDecimalPositivePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleDecimalPositive", nil, "Failure preparing request") @@ -911,6 +1062,16 @@ func (client QueriesClient) DoubleDecimalPositiveResponder(resp *http.Response) // Parameters: // doubleQuery - null numeric value func (client QueriesClient) DoubleNull(ctx context.Context, doubleQuery *float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DoubleNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.DoubleNullPreparer(ctx, doubleQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleNull", nil, "Failure preparing request") @@ -970,6 +1131,16 @@ func (client QueriesClient) DoubleNullResponder(resp *http.Response) (result aut // Parameters: // enumQuery - null string value func (client QueriesClient) EnumNull(ctx context.Context, enumQuery URIColor) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.EnumNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.EnumNullPreparer(ctx, enumQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "EnumNull", nil, "Failure preparing request") @@ -1029,6 +1200,16 @@ func (client QueriesClient) EnumNullResponder(resp *http.Response) (result autor // Parameters: // enumQuery - 'green color' enum value func (client QueriesClient) EnumValid(ctx context.Context, enumQuery URIColor) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.EnumValid") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.EnumValidPreparer(ctx, enumQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "EnumValid", nil, "Failure preparing request") @@ -1088,6 +1269,16 @@ func (client QueriesClient) EnumValidResponder(resp *http.Response) (result auto // Parameters: // floatQuery - null numeric value func (client QueriesClient) FloatNull(ctx context.Context, floatQuery *float64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.FloatNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.FloatNullPreparer(ctx, floatQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatNull", nil, "Failure preparing request") @@ -1145,6 +1336,16 @@ func (client QueriesClient) FloatNullResponder(resp *http.Response) (result auto // FloatScientificNegative get '-1.034E-20' numeric value func (client QueriesClient) FloatScientificNegative(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.FloatScientificNegative") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.FloatScientificNegativePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatScientificNegative", nil, "Failure preparing request") @@ -1201,6 +1402,16 @@ func (client QueriesClient) FloatScientificNegativeResponder(resp *http.Response // FloatScientificPositive get '1.034E+20' numeric value func (client QueriesClient) FloatScientificPositive(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.FloatScientificPositive") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.FloatScientificPositivePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatScientificPositive", nil, "Failure preparing request") @@ -1257,6 +1468,16 @@ func (client QueriesClient) FloatScientificPositiveResponder(resp *http.Response // GetBooleanFalse get false Boolean value on path func (client QueriesClient) GetBooleanFalse(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetBooleanFalse") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanFalsePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanFalse", nil, "Failure preparing request") @@ -1315,6 +1536,16 @@ func (client QueriesClient) GetBooleanFalseResponder(resp *http.Response) (resul // Parameters: // boolQuery - null boolean value func (client QueriesClient) GetBooleanNull(ctx context.Context, boolQuery *bool) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetBooleanNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanNullPreparer(ctx, boolQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanNull", nil, "Failure preparing request") @@ -1372,6 +1603,16 @@ func (client QueriesClient) GetBooleanNullResponder(resp *http.Response) (result // GetBooleanTrue get true Boolean value on path func (client QueriesClient) GetBooleanTrue(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetBooleanTrue") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetBooleanTruePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanTrue", nil, "Failure preparing request") @@ -1428,6 +1669,16 @@ func (client QueriesClient) GetBooleanTrueResponder(resp *http.Response) (result // GetIntNegativeOneMillion get '-1000000' integer value func (client QueriesClient) GetIntNegativeOneMillion(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetIntNegativeOneMillion") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntNegativeOneMillionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntNegativeOneMillion", nil, "Failure preparing request") @@ -1486,6 +1737,16 @@ func (client QueriesClient) GetIntNegativeOneMillionResponder(resp *http.Respons // Parameters: // intQuery - null integer value func (client QueriesClient) GetIntNull(ctx context.Context, intQuery *int32) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetIntNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntNullPreparer(ctx, intQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntNull", nil, "Failure preparing request") @@ -1543,6 +1804,16 @@ func (client QueriesClient) GetIntNullResponder(resp *http.Response) (result aut // GetIntOneMillion get '1000000' integer value func (client QueriesClient) GetIntOneMillion(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetIntOneMillion") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetIntOneMillionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntOneMillion", nil, "Failure preparing request") @@ -1601,6 +1872,16 @@ func (client QueriesClient) GetIntOneMillionResponder(resp *http.Response) (resu // Parameters: // longQuery - null 64 bit integer value func (client QueriesClient) GetLongNull(ctx context.Context, longQuery *int64) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetLongNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetLongNullPreparer(ctx, longQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetLongNull", nil, "Failure preparing request") @@ -1658,6 +1939,16 @@ func (client QueriesClient) GetLongNullResponder(resp *http.Response) (result au // GetNegativeTenBillion get '-10000000000' 64 bit integer value func (client QueriesClient) GetNegativeTenBillion(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetNegativeTenBillion") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetNegativeTenBillionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetNegativeTenBillion", nil, "Failure preparing request") @@ -1714,6 +2005,16 @@ func (client QueriesClient) GetNegativeTenBillionResponder(resp *http.Response) // GetTenBillion get '10000000000' 64 bit integer value func (client QueriesClient) GetTenBillion(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetTenBillion") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetTenBillionPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetTenBillion", nil, "Failure preparing request") @@ -1770,6 +2071,16 @@ func (client QueriesClient) GetTenBillionResponder(resp *http.Response) (result // StringEmpty get '' func (client QueriesClient) StringEmpty(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.StringEmpty") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.StringEmptyPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringEmpty", nil, "Failure preparing request") @@ -1828,6 +2139,16 @@ func (client QueriesClient) StringEmptyResponder(resp *http.Response) (result au // Parameters: // stringQuery - null string value func (client QueriesClient) StringNull(ctx context.Context, stringQuery string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.StringNull") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.StringNullPreparer(ctx, stringQuery) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringNull", nil, "Failure preparing request") @@ -1885,6 +2206,16 @@ func (client QueriesClient) StringNullResponder(resp *http.Response) (result aut // StringUnicode get '啊齄丂狛狜隣郎隣兀﨩' multi-byte string value func (client QueriesClient) StringUnicode(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.StringUnicode") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.StringUnicodePreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringUnicode", nil, "Failure preparing request") @@ -1941,6 +2272,16 @@ func (client QueriesClient) StringUnicodeResponder(resp *http.Response) (result // StringURLEncoded get 'begin!*'();:@ &=+$,/?#[]end func (client QueriesClient) StringURLEncoded(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.StringURLEncoded") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.StringURLEncodedPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringURLEncoded", nil, "Failure preparing request") diff --git a/test/src/tests/generated/validation/client.go b/test/src/tests/generated/validation/client.go index fc1e8c4e2..fe2936428 100644 --- a/test/src/tests/generated/validation/client.go +++ b/test/src/tests/generated/validation/client.go @@ -14,6 +14,7 @@ import ( "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" "net/http" ) @@ -45,6 +46,16 @@ func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient { // GetWithConstantInPath sends the get with constant in path request. func (client BaseClient) GetWithConstantInPath(ctx context.Context) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetWithConstantInPath") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } req, err := client.GetWithConstantInPathPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "validationgroup.BaseClient", "GetWithConstantInPath", nil, "Failure preparing request") @@ -100,6 +111,16 @@ func (client BaseClient) GetWithConstantInPathResponder(resp *http.Response) (re // PostWithConstantInBody sends the post with constant in body request. func (client BaseClient) PostWithConstantInBody(ctx context.Context, body *Product) (result Product, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PostWithConstantInBody") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: body, Constraints: []validation.Constraint{{Target: "body", Name: validation.Null, Rule: false, @@ -190,6 +211,16 @@ func (client BaseClient) PostWithConstantInBodyResponder(resp *http.Response) (r // resourceGroupName - required string between 3 and 10 chars with pattern [a-zA-Z0-9]+. // ID - required int multiple of 10 from 100 to 1000. func (client BaseClient) ValidationOfBody(ctx context.Context, resourceGroupName string, ID int32, body *Product) (result Product, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.ValidationOfBody") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: resourceGroupName, Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 10, Chain: nil}, @@ -296,6 +327,16 @@ func (client BaseClient) ValidationOfBodyResponder(resp *http.Response) (result // resourceGroupName - required string between 3 and 10 chars with pattern [a-zA-Z0-9]+. // ID - required int multiple of 10 from 100 to 1000. func (client BaseClient) ValidationOfMethodParameters(ctx context.Context, resourceGroupName string, ID int32) (result Product, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.ValidationOfMethodParameters") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } if err := validation.Validate([]validation.Validation{ {TargetValue: resourceGroupName, Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 10, Chain: nil}, diff --git a/test/src/tests/generated/validation/models.go b/test/src/tests/generated/validation/models.go index ca661078d..4007c97c6 100644 --- a/test/src/tests/generated/validation/models.go +++ b/test/src/tests/generated/validation/models.go @@ -10,6 +10,9 @@ import ( "github.com/Azure/go-autorest/autorest" ) +// The package's fully qualified name. +const fqdn = "test/src/tests/generated/validation" + // EnumConst enumerates the values for enum const. type EnumConst string