diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
| commit | 19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch) | |
| tree | 42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /src/jaegertracing/jaeger-client-cpp | |
| parent | Initial commit. (diff) | |
| download | ceph-upstream/16.2.11+ds.tar.xz ceph-upstream/16.2.11+ds.zip | |
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/jaegertracing/jaeger-client-cpp')
289 files changed, 33192 insertions, 0 deletions
diff --git a/src/jaegertracing/jaeger-client-cpp/.appveyor.yml b/src/jaegertracing/jaeger-client-cpp/.appveyor.yml new file mode 100644 index 000000000..f0c30e4f0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.appveyor.yml @@ -0,0 +1,25 @@ +version: '{build}' + +image: Visual Studio 2017 + +init: + - cmd: git config --global core.autocrlf true + +platform: + - x64 + +configuration: + - Debug + +before_build: + - cmake -H. -Bbuild -A%PLATFORM% -DBUILD_TESTING=ON + +build: + project: build\jaegertracing.sln + parallel: true + verbosity: normal + +test_script: +- ps: | + cd build + ctest -V -C $env:configuration --timeout 600 --output-on-failure
\ No newline at end of file diff --git a/src/jaegertracing/jaeger-client-cpp/.clang-format b/src/jaegertracing/jaeger-client-cpp/.clang-format new file mode 100644 index 000000000..7e6effd2e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.clang-format @@ -0,0 +1,83 @@ +Language: Cpp +AccessModifierOffset: -2 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlinesLeft: false +AlignOperands: true +AlignTrailingComments: false +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: true +AlwaysBreakTemplateDeclarations: true +BinPackArguments: false +BinPackParameters: false +BraceWrapping: + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: true + AfterNamespace: false + AfterStruct: false + AfterUnion: false + BeforeCatch: false + BeforeElse: true + IndentBraces: false +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Custom +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: false +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + - Regex: '^(<|"(gtest|isl|json)/)' + Priority: 3 + - Regex: '.*' + Priority: 1 +IndentCaseLabels: false +IndentWidth: 4 +IndentWrappedFunctionNames: false +KeepEmptyLinesAtTheStartOfBlocks: true +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBlockIndentWidth: 4 +ObjCSpaceAfterProperty: true +ObjCSpaceBeforeProtocolList: true +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Left +ReflowComments: true +SortIncludes: true +SpaceAfterCStyleCast: false +SpaceBeforeAssignmentOperators: true +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 2 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Cpp11 +UseTab: Never diff --git a/src/jaegertracing/jaeger-client-cpp/.clang-tidy b/src/jaegertracing/jaeger-client-cpp/.clang-tidy new file mode 100644 index 000000000..895d42054 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.clang-tidy @@ -0,0 +1,407 @@ +Checks: 'clang-diagnostic-*,clang-analyzer-*,*' +WarningsAsErrors: '' +HeaderFilterRegex: '' +AnalyzeTemporaryDtors: false +CheckOptions: + - key: cert-dcl59-cpp.HeaderFileExtensions + value: h,hh,hpp,hxx + - key: cert-err09-cpp.CheckThrowTemporaries + value: '1' + - key: cert-err61-cpp.CheckThrowTemporaries + value: '1' + - key: cert-oop11-cpp.IncludeStyle + value: llvm + - key: cppcoreguidelines-pro-bounds-constant-array-index.GslHeader + value: '' + - key: cppcoreguidelines-pro-bounds-constant-array-index.IncludeStyle + value: '0' + - key: cppcoreguidelines-pro-type-member-init.IgnoreArrays + value: '0' + - key: google-build-namespaces.HeaderFileExtensions + value: h,hh,hpp,hxx + - key: google-global-names-in-headers.HeaderFileExtensions + value: h + - key: google-readability-braces-around-statements.ShortStatementLines + value: '1' + - key: google-readability-function-size.BranchThreshold + value: '4294967295' + - key: google-readability-function-size.LineThreshold + value: '4294967295' + - key: google-readability-function-size.StatementThreshold + value: '800' + - key: google-readability-namespace-comments.ShortNamespaceLines + value: '10' + - key: google-readability-namespace-comments.SpacesBeforeComments + value: '2' + - key: google-runtime-int.SignedTypePrefix + value: int + - key: google-runtime-int.TypeSuffix + value: '' + - key: google-runtime-int.UnsignedTypePrefix + value: uint + - key: google-runtime-references.WhiteListTypes + value: '' + - key: llvm-header-guard.HeaderFileExtensions + value: ',h,hh,hpp,hxx' + - key: llvm-namespace-comment.ShortNamespaceLines + value: '1' + - key: llvm-namespace-comment.SpacesBeforeComments + value: '1' + - key: misc-argument-comment.StrictMode + value: '0' + - key: misc-assert-side-effect.AssertMacros + value: assert + - key: misc-assert-side-effect.CheckFunctionCalls + value: '0' + - key: misc-dangling-handle.HandleClasses + value: 'std::basic_string_view;std::experimental::basic_string_view' + - key: misc-definitions-in-headers.HeaderFileExtensions + value: ',h,hh,hpp,hxx' + - key: misc-definitions-in-headers.UseHeaderFileExtension + value: '1' + - key: misc-misplaced-widening-cast.CheckImplicitCasts + value: '1' + - key: misc-move-constructor-init.IncludeStyle + value: llvm + - key: misc-sizeof-expression.WarnOnSizeOfCompareToConstant + value: '1' + - key: misc-sizeof-expression.WarnOnSizeOfConstant + value: '1' + - key: misc-sizeof-expression.WarnOnSizeOfThis + value: '1' + - key: misc-string-constructor.LargeLengthThreshold + value: '8388608' + - key: misc-string-constructor.WarnOnLargeLength + value: '1' + - key: misc-suspicious-enum-usage.StrictMode + value: '0' + - key: misc-suspicious-missing-comma.MaxConcatenatedTokens + value: '5' + - key: misc-suspicious-missing-comma.RatioThreshold + value: '0.200000' + - key: misc-suspicious-missing-comma.SizeThreshold + value: '5' + - key: misc-suspicious-string-compare.StringCompareLikeFunctions + value: '' + - key: misc-suspicious-string-compare.WarnOnImplicitComparison + value: '1' + - key: misc-suspicious-string-compare.WarnOnLogicalNotComparison + value: '0' + - key: misc-throw-by-value-catch-by-reference.CheckThrowTemporaries + value: '1' + - key: modernize-loop-convert.MaxCopySize + value: '16' + - key: modernize-loop-convert.MinConfidence + value: reasonable + - key: modernize-loop-convert.NamingStyle + value: CamelCase + - key: modernize-pass-by-value.IncludeStyle + value: llvm + - key: modernize-pass-by-value.ValuesOnly + value: '0' + - key: modernize-replace-auto-ptr.IncludeStyle + value: llvm + - key: modernize-use-auto.RemoveStars + value: '0' + - key: modernize-use-default-member-init.UseAssignment + value: '0' + - key: modernize-use-emplace.ContainersWithPushBack + value: '::std::vector;::std::list;::std::deque' + - key: modernize-use-emplace.SmartPointers + value: '::std::shared_ptr;::std::unique_ptr;::std::auto_ptr;::std::weak_ptr' + - key: modernize-use-nullptr.NullMacros + value: 'NULL' + - key: modernize-use-transparent-functors.SafeMode + value: '0' + - key: performance-faster-string-find.StringLikeClasses + value: 'std::basic_string' + - key: performance-for-range-copy.WarnOnAllAutoCopies + value: '0' + - key: performance-inefficient-string-concatenation.StrictMode + value: '0' + - key: performance-type-promotion-in-math-fn.IncludeStyle + value: llvm + - key: performance-unnecessary-value-param.IncludeStyle + value: llvm + - key: readability-braces-around-statements.ShortStatementLines + value: '0' + - key: readability-function-size.BranchThreshold + value: '4294967295' + - key: readability-function-size.LineThreshold + value: '4294967295' + - key: readability-function-size.StatementThreshold + value: '800' + - key: readability-identifier-naming.AbstractClassCase + value: aNy_CasE + - key: readability-identifier-naming.AbstractClassPrefix + value: '' + - key: readability-identifier-naming.AbstractClassSuffix + value: '' + - key: readability-identifier-naming.ClassCase + value: aNy_CasE + - key: readability-identifier-naming.ClassConstantCase + value: aNy_CasE + - key: readability-identifier-naming.ClassConstantPrefix + value: '' + - key: readability-identifier-naming.ClassConstantSuffix + value: '' + - key: readability-identifier-naming.ClassMemberCase + value: aNy_CasE + - key: readability-identifier-naming.ClassMemberPrefix + value: '' + - key: readability-identifier-naming.ClassMemberSuffix + value: '' + - key: readability-identifier-naming.ClassMethodCase + value: aNy_CasE + - key: readability-identifier-naming.ClassMethodPrefix + value: '' + - key: readability-identifier-naming.ClassMethodSuffix + value: '' + - key: readability-identifier-naming.ClassPrefix + value: '' + - key: readability-identifier-naming.ClassSuffix + value: '' + - key: readability-identifier-naming.ConstantCase + value: aNy_CasE + - key: readability-identifier-naming.ConstantMemberCase + value: aNy_CasE + - key: readability-identifier-naming.ConstantMemberPrefix + value: '' + - key: readability-identifier-naming.ConstantMemberSuffix + value: '' + - key: readability-identifier-naming.ConstantParameterCase + value: aNy_CasE + - key: readability-identifier-naming.ConstantParameterPrefix + value: '' + - key: readability-identifier-naming.ConstantParameterSuffix + value: '' + - key: readability-identifier-naming.ConstantPrefix + value: '' + - key: readability-identifier-naming.ConstantSuffix + value: '' + - key: readability-identifier-naming.ConstexprFunctionCase + value: aNy_CasE + - key: readability-identifier-naming.ConstexprFunctionPrefix + value: '' + - key: readability-identifier-naming.ConstexprFunctionSuffix + value: '' + - key: readability-identifier-naming.ConstexprMethodCase + value: aNy_CasE + - key: readability-identifier-naming.ConstexprMethodPrefix + value: '' + - key: readability-identifier-naming.ConstexprMethodSuffix + value: '' + - key: readability-identifier-naming.ConstexprVariableCase + value: aNy_CasE + - key: readability-identifier-naming.ConstexprVariablePrefix + value: '' + - key: readability-identifier-naming.ConstexprVariableSuffix + value: '' + - key: readability-identifier-naming.EnumCase + value: aNy_CasE + - key: readability-identifier-naming.EnumConstantCase + value: aNy_CasE + - key: readability-identifier-naming.EnumConstantPrefix + value: '' + - key: readability-identifier-naming.EnumConstantSuffix + value: '' + - key: readability-identifier-naming.EnumPrefix + value: '' + - key: readability-identifier-naming.EnumSuffix + value: '' + - key: readability-identifier-naming.FunctionCase + value: aNy_CasE + - key: readability-identifier-naming.FunctionPrefix + value: '' + - key: readability-identifier-naming.FunctionSuffix + value: '' + - key: readability-identifier-naming.GlobalConstantCase + value: aNy_CasE + - key: readability-identifier-naming.GlobalConstantPrefix + value: '' + - key: readability-identifier-naming.GlobalConstantSuffix + value: '' + - key: readability-identifier-naming.GlobalFunctionCase + value: aNy_CasE + - key: readability-identifier-naming.GlobalFunctionPrefix + value: '' + - key: readability-identifier-naming.GlobalFunctionSuffix + value: '' + - key: readability-identifier-naming.GlobalVariableCase + value: aNy_CasE + - key: readability-identifier-naming.GlobalVariablePrefix + value: '' + - key: readability-identifier-naming.GlobalVariableSuffix + value: '' + - key: readability-identifier-naming.IgnoreFailedSplit + value: '0' + - key: readability-identifier-naming.InlineNamespaceCase + value: aNy_CasE + - key: readability-identifier-naming.InlineNamespacePrefix + value: '' + - key: readability-identifier-naming.InlineNamespaceSuffix + value: '' + - key: readability-identifier-naming.LocalConstantCase + value: aNy_CasE + - key: readability-identifier-naming.LocalConstantPrefix + value: '' + - key: readability-identifier-naming.LocalConstantSuffix + value: '' + - key: readability-identifier-naming.LocalVariableCase + value: aNy_CasE + - key: readability-identifier-naming.LocalVariablePrefix + value: '' + - key: readability-identifier-naming.LocalVariableSuffix + value: '' + - key: readability-identifier-naming.MacroDefinitionCase + value: aNy_CasE + - key: readability-identifier-naming.MacroDefinitionPrefix + value: '' + - key: readability-identifier-naming.MacroDefinitionSuffix + value: '' + - key: readability-identifier-naming.MemberCase + value: aNy_CasE + - key: readability-identifier-naming.MemberPrefix + value: '' + - key: readability-identifier-naming.MemberSuffix + value: '' + - key: readability-identifier-naming.MethodCase + value: aNy_CasE + - key: readability-identifier-naming.MethodPrefix + value: '' + - key: readability-identifier-naming.MethodSuffix + value: '' + - key: readability-identifier-naming.NamespaceCase + value: aNy_CasE + - key: readability-identifier-naming.NamespacePrefix + value: '' + - key: readability-identifier-naming.NamespaceSuffix + value: '' + - key: readability-identifier-naming.ParameterCase + value: aNy_CasE + - key: readability-identifier-naming.ParameterPackCase + value: aNy_CasE + - key: readability-identifier-naming.ParameterPackPrefix + value: '' + - key: readability-identifier-naming.ParameterPackSuffix + value: '' + - key: readability-identifier-naming.ParameterPrefix + value: '' + - key: readability-identifier-naming.ParameterSuffix + value: '' + - key: readability-identifier-naming.PrivateMemberCase + value: aNy_CasE + - key: readability-identifier-naming.PrivateMemberPrefix + value: '' + - key: readability-identifier-naming.PrivateMemberSuffix + value: '' + - key: readability-identifier-naming.PrivateMethodCase + value: aNy_CasE + - key: readability-identifier-naming.PrivateMethodPrefix + value: '' + - key: readability-identifier-naming.PrivateMethodSuffix + value: '' + - key: readability-identifier-naming.ProtectedMemberCase + value: aNy_CasE + - key: readability-identifier-naming.ProtectedMemberPrefix + value: '' + - key: readability-identifier-naming.ProtectedMemberSuffix + value: '' + - key: readability-identifier-naming.ProtectedMethodCase + value: aNy_CasE + - key: readability-identifier-naming.ProtectedMethodPrefix + value: '' + - key: readability-identifier-naming.ProtectedMethodSuffix + value: '' + - key: readability-identifier-naming.PublicMemberCase + value: aNy_CasE + - key: readability-identifier-naming.PublicMemberPrefix + value: '' + - key: readability-identifier-naming.PublicMemberSuffix + value: '' + - key: readability-identifier-naming.PublicMethodCase + value: aNy_CasE + - key: readability-identifier-naming.PublicMethodPrefix + value: '' + - key: readability-identifier-naming.PublicMethodSuffix + value: '' + - key: readability-identifier-naming.StaticConstantCase + value: aNy_CasE + - key: readability-identifier-naming.StaticConstantPrefix + value: '' + - key: readability-identifier-naming.StaticConstantSuffix + value: '' + - key: readability-identifier-naming.StaticVariableCase + value: aNy_CasE + - key: readability-identifier-naming.StaticVariablePrefix + value: '' + - key: readability-identifier-naming.StaticVariableSuffix + value: '' + - key: readability-identifier-naming.StructCase + value: aNy_CasE + - key: readability-identifier-naming.StructPrefix + value: '' + - key: readability-identifier-naming.StructSuffix + value: '' + - key: readability-identifier-naming.TemplateParameterCase + value: aNy_CasE + - key: readability-identifier-naming.TemplateParameterPrefix + value: '' + - key: readability-identifier-naming.TemplateParameterSuffix + value: '' + - key: readability-identifier-naming.TemplateTemplateParameterCase + value: aNy_CasE + - key: readability-identifier-naming.TemplateTemplateParameterPrefix + value: '' + - key: readability-identifier-naming.TemplateTemplateParameterSuffix + value: '' + - key: readability-identifier-naming.TypeAliasCase + value: aNy_CasE + - key: readability-identifier-naming.TypeAliasPrefix + value: '' + - key: readability-identifier-naming.TypeAliasSuffix + value: '' + - key: readability-identifier-naming.TypeTemplateParameterCase + value: aNy_CasE + - key: readability-identifier-naming.TypeTemplateParameterPrefix + value: '' + - key: readability-identifier-naming.TypeTemplateParameterSuffix + value: '' + - key: readability-identifier-naming.TypedefCase + value: aNy_CasE + - key: readability-identifier-naming.TypedefPrefix + value: '' + - key: readability-identifier-naming.TypedefSuffix + value: '' + - key: readability-identifier-naming.UnionCase + value: aNy_CasE + - key: readability-identifier-naming.UnionPrefix + value: '' + - key: readability-identifier-naming.UnionSuffix + value: '' + - key: readability-identifier-naming.ValueTemplateParameterCase + value: aNy_CasE + - key: readability-identifier-naming.ValueTemplateParameterPrefix + value: '' + - key: readability-identifier-naming.ValueTemplateParameterSuffix + value: '' + - key: readability-identifier-naming.VariableCase + value: aNy_CasE + - key: readability-identifier-naming.VariablePrefix + value: '' + - key: readability-identifier-naming.VariableSuffix + value: '' + - key: readability-identifier-naming.VirtualMethodCase + value: aNy_CasE + - key: readability-identifier-naming.VirtualMethodPrefix + value: '' + - key: readability-identifier-naming.VirtualMethodSuffix + value: '' + - key: readability-implicit-bool-cast.AllowConditionalIntegerCasts + value: '0' + - key: readability-implicit-bool-cast.AllowConditionalPointerCasts + value: '0' + - key: readability-simplify-boolean-expr.ChainedConditionalAssignment + value: '0' + - key: readability-simplify-boolean-expr.ChainedConditionalReturn + value: '0' diff --git a/src/jaegertracing/jaeger-client-cpp/.github/ISSUE_TEMPLATE.md b/src/jaegertracing/jaeger-client-cpp/.github/ISSUE_TEMPLATE.md new file mode 100644 index 000000000..7a5851ba9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,28 @@ +<!-- +Welcome to the Jaeger project! 👋🎉 + +- Please search for existing issues to avoid creating duplicate bugs/feature requests. +- Please be respectful and considerate of others when commenting on issues. +- Please provide as much information as possible so we all understand the issue. +- If you only have a question, you may get a faster response by asking in + - our chat room https://gitter.im/jaegertracing/Lobby, or + - the forum https://groups.google.com/d/forum/jaeger-tracing + (but please don't double post) +--> + +## Requirement - what kind of business use case are you trying to solve? + +<!-- required section --> + +## Problem - what in Jaeger blocks you from solving the requirement? + +<!-- required section --> +<!-- If possible, describe the impact of the problem. --> + +## Proposal - what do you suggest to solve the problem or improve the existing situation? + +<!-- It's ok if you don't have one. --> + +## Any open questions to address + +<!-- Questions that should be answered before proceeding with implementation. --> diff --git a/src/jaegertracing/jaeger-client-cpp/.github/PULL_REQUEST_TEMPLATE.md b/src/jaegertracing/jaeger-client-cpp/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 000000000..2564119cc --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,18 @@ +<!-- +We appreciate your contribution to the Jaeger project! 👋🎉 + +Before creating a pull request, please make sure: +- Your PR is solving one problem +- You have read the guide for contributing + - See https://github.com/jaegertracing/jaeger/blob/master/CONTRIBUTING_GUIDELINES.md +- You signed all your commits (otherwise we won't be able to merge the PR) + - See https://github.com/jaegertracing/jaeger/blob/master/CONTRIBUTING_GUIDELINES.md#sign-your-work +- You added unit tests for the new functionality +- You mention in the PR description which issue it is addressing, e.g. "Resolves #123" +--> + +## Which problem is this PR solving? +- + +## Short description of the changes +- diff --git a/src/jaegertracing/jaeger-client-cpp/.gitignore b/src/jaegertracing/jaeger-client-cpp/.gitignore new file mode 100644 index 000000000..780302494 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.gitignore @@ -0,0 +1,48 @@ +# Build files +/build +/crossdock/crossdock +/crossdock/jaeger-docker-compose.yml + +# vim swap files +*.swo +*.swp + +# Prerequisites +*.d + +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod +*.smod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app + +# Log files +*.log + +# CLion folders +cmake-build-debug +.idea diff --git a/src/jaegertracing/jaeger-client-cpp/.gitmodules b/src/jaegertracing/jaeger-client-cpp/.gitmodules new file mode 100644 index 000000000..295ebcf62 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.gitmodules @@ -0,0 +1,3 @@ +[submodule "idl"] + path = idl + url = https://github.com/uber/jaeger-idl.git diff --git a/src/jaegertracing/jaeger-client-cpp/.travis.yml b/src/jaegertracing/jaeger-client-cpp/.travis.yml new file mode 100644 index 000000000..9c380d450 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.travis.yml @@ -0,0 +1,88 @@ +language: cpp +sudo: true +dist: trusty +addons: + apt: + packages: &1 + - lcov +matrix: + include: + - os: linux + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - *1 + - g++-4.9 + env: + - MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9 && CMAKE_OPTIONS='-DCMAKE_BUILD_TYPE=Debug + -DBUILD_SHARED_LIBS=ON -DJAEGERTRACING_COVERAGE=ON'" + - os: linux + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - *1 + - g++-5 + env: + - MATRIX_EVAL="CC=gcc-5 && CXX=g++-5 && CMAKE_OPTIONS='-DCMAKE_BUILD_TYPE=Debug + -DBUILD_SHARED_LIBS=ON -DJAEGERTRACING_COVERAGE=ON'" + - os: linux + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - *1 + - g++-6 + env: + - MATRIX_EVAL="CC=gcc-6 && CXX=g++-6 && CMAKE_OPTIONS='-DCMAKE_BUILD_TYPE=Debug + -DBUILD_SHARED_LIBS=ON -DJAEGERTRACING_COVERAGE=ON'" + - os: linux + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - *1 + - g++-7 + env: + - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7 && CMAKE_OPTIONS='-DCMAKE_BUILD_TYPE=Debug + -DBUILD_SHARED_LIBS=ON -DJAEGERTRACING_COVERAGE=ON'" + - os: linux + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - *1 + - g++-7 + env: + - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7 && CMAKE_OPTIONS='-DCMAKE_BUILD_TYPE=Release + -DJAEGERTRACING_PLUGIN=ON -DBUILD_TESTING=ON -DHUNTER_CONFIGURATION_TYPES=Release'" +before_install: +- eval "${MATRIX_EVAL}" +- mkdir cmake-download && cd cmake-download && curl -O https://cmake.org/files/v3.10/cmake-3.10.0-rc5-Linux-x86_64.sh + && bash cmake-3.10.0-rc5-Linux-x86_64.sh --skip-license && cd .. +script: +- CMAKE_OPTIONS="${CMAKE_OPTIONS}" ./scripts/build.sh +after_success: +- CMAKE_OPTIONS="${CMAKE_OPTIONS}" ./scripts/upload-coverage.sh +cache: + directories: + - "$HOME/.hunter/_Base/Cache" +env: + global: + - LANG="en_US.UTF-8" + - PATH="$TRAVIS_BUILD_DIR/cmake-download/bin:$PATH" +deploy: + provider: releases + api_key: + secure: Q2ZlNb0QHRfS+uZ4q9EEsWjv7s1EFqahF8aDLpoO8brSaLtImcMM5G9MHukxjh57NJnM0S9FOU6hJyAnSt8hOjmQH+7oXwvt1Uoqh5gmPXpxhmIcK753JxXeeKID6nxBImTk8JjBRV164k7Oyj401t8WqKYZB+s5PuZq4ND854Ak/kFFsZbMunsy0RX8LxrYTuxc3YBwWfa1oFXJIqxWN/J1YV6hSdCNtWuk2re796leql3vkNEogHUCHvTB/lmM4egcsF21TkpOuRrCww/DYTx4eLCjvwJKtGuLq8FKC8uMLMG5b2JgllpfFbEq5o6imqioKUjTuoS0TE0KzM4WQFgYo7itykgZRD3pvivSK8mJePjTjuDQukQ6i1PkT9wgxdkagPH/mD+JBzx+cAzy3jPgfxWFl29Yj1xsKpbUmeSjxWac87b8d3lEBfBNJ83QkfkC80ZrJufhy30RP47PTHLUNf/udiO722T6w6Zu6wEKFSjfoRqPa0Uj2Src8tonKt7Me9UDoHAJ+go0nIz27xc4haPFgg5NgxSSXDn9fAEiLlj48tQkI6bUl1U+HH1baWHoTrckUi7OpJZYU9zB4QLwhia7OhrVvNWtTIbyVF4+8OIw4uaMsEV3jsR0okREUKSH/yPGiouFvoiggVa3OIGDN+CLQ/7Pocw8msBSQ0U= + file: build/libjaegertracing_plugin.so + on: + repo: jaegertracing/jaeger-client-cpp + tags: true + skip_cleanup: true diff --git a/src/jaegertracing/jaeger-client-cpp/.ycm_extra_conf.py b/src/jaegertracing/jaeger-client-cpp/.ycm_extra_conf.py new file mode 100644 index 000000000..ad3fcc3d7 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/.ycm_extra_conf.py @@ -0,0 +1,104 @@ +# Copyright (c) 2017-2018 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import ycm_core + + +def DirectoryOfThisScript(): + return os.path.dirname( os.path.abspath( __file__ ) ) + + +project_dir = DirectoryOfThisScript() + +try: + with open('build/_3rdParty/Hunter/install-root-dir') as f: + hunter_install_dir = f.readline() +except IOError: + # Ignore if file does not exist + hunter_install_dir = '' + +flags = [ +'-Wall', +'-Werror', +'-pedantic', +'-std=c++11', +'-x', +'c++', +'-DBOOST_COROUTINES_NO_DEPRECATION_WARNING=1', +'-DGTEST_HAS_TR1_TUPLE=0', +'-DGTEST_USE_OWN_TR1_TUPLE=0', +'-isystem', +'/usr/local/include', +'-I', +os.path.join(project_dir, 'src'), +'-I', +os.path.join(project_dir, 'build/src') +] + +if hunter_install_dir: + flags += ['-I', hunter_install_dir] + +compilation_database_folder = os.path.join(project_dir, 'build') + +if os.path.exists( compilation_database_folder ): + database = ycm_core.CompilationDatabase( compilation_database_folder ) +else: + database = None + +SOURCE_EXTENSIONS = [ '.cpp', '.cxx', '.cc', '.c', '.m', '.mm' ] + + +def IsHeaderFile( filename ): + extension = os.path.splitext( filename )[ 1 ] + return extension in [ '.h', '.hxx', '.hpp', '.hh' ] + + +def GetCompilationInfoForFile( filename ): + # The compilation_commands.json file generated by CMake does not have entries + # for header files. So we do our best by asking the db for flags for a + # corresponding source file, if any. If one exists, the flags for that file + # should be good enough. + if IsHeaderFile( filename ): + basename = os.path.splitext( filename )[ 0 ] + for extension in SOURCE_EXTENSIONS: + replacement_file = basename + extension + if os.path.exists( replacement_file ): + compilation_info = database.GetCompilationInfoForFile( + replacement_file ) + if compilation_info.compiler_flags_: + return compilation_info + return None + return database.GetCompilationInfoForFile( filename ) + + +def FlagsForFile( filename, **kwargs ): + if not database: + return { + 'flags': flags, + 'include_paths_relative_to_dir': DirectoryOfThisScript() + } + + compilation_info = GetCompilationInfoForFile( filename ) + if not compilation_info: + return None + + # Bear in mind that compilation_info.compiler_flags_ does NOT return a + # python list, but a "list-like" StringVec object. + final_flags = list( compilation_info.compiler_flags_ ) + + return { + 'flags': final_flags, + 'include_paths_relative_to_dir': compilation_info.compiler_working_dir_ + } diff --git a/src/jaegertracing/jaeger-client-cpp/CHANGELOG.md b/src/jaegertracing/jaeger-client-cpp/CHANGELOG.md new file mode 100644 index 000000000..da24edf1b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/CHANGELOG.md @@ -0,0 +1,89 @@ +Changes by Version +================== + +0.6.1 (unreleased) +------------------ + +- Nothing yet. + + +0.6.0 (2020-06-08) +------------------ +- Support plugin configuration via environment variables (#192) +- An extension of enum opentracing::SpanReferenceType, for a new Span. (#206) +- Update OpenTracing to 1.6.0 (#209) +- Fix loading of sampling endpoint address from JAEGER_SAMPLING_ENDPOINT environment variable (#200) +- Fix sampling endpoint URL +- Fix typo in README.md (#194) +- Add jaeger-debug-id as a tag (#190) +- Reuse TMemoryBuffer when calculating size of ThriftType (#185) +- Support Tracer tags and configuration via environment variables (#181) +- Add an HTTP Sender (#165) (#171) +- Remove Thrift headers from Jaeger public headers (#172) +- Update default samplingServerURL to include /sampling path (#158) + + +0.5.0 (2019-09-07) +------------------ +- Improve C++ flag handling in CMake (#128) +- localIP: try resolving local hostname first (#130) +- Fix deadlock if steady_clock::now() returns the same value twice (#132) +- Implement SpanContext::Clone (#138) +- Change sampler param sentinel value from YAML parser (#145) +- Fix RemoteReporter test race condition (#135) +- Add details on how to set agent & collector endpoint (#153) +- Clarify agent/sampler address overrides in README +- Upgrade to OpenTracing 1.5.0; Support build on Windows (#115) +- Throw exception on invalid sampling rate (#168) + + +0.4.2 (2018-08-14) +------------------ +- Fix `tracer.Inject(..., HTTPHeadersWriter&)` (#107) +- Upgrade dynamic loading API (#120) + + +0.4.1 (2018-05-16) +------------------ +- Add example application (#101) +- Improve CMake installation to allow use of lib64 directory (#102) +- Fix CMake config for OpenTracing dependency (#103) +- Fix tracer inject for HTTP headers (#107) + + +0.4.0 (2018-05-07) +------------------ +- Build shared plugin for Linux amd64 using Docker (#82) +- Fix UDP test compilation error (#88) +- Fix usage of propagation headers config (#91) +- Fix dynamic load build error (#92) +- Use Thrift 0.11.0 (#94) + + +0.3.0 (2018-04-17) +------------------ +- Use LogRecord in Span::FinishWithOptions (#58) +- Flush pending spans in RemoteReporter destructor (#59) +- Add support for dynamic loading (#64) +- Fix unhandled exception when Jaeger agent unavailable (#80) +- Fix potential race condition in concurrent baggage access (#83) + + +0.2.0 (2018-01-25) +------------------ +- Fix bug in localIP and revert change in TR1 tuple definition (#31) +- Add language prefix to Jaeger client version tag (#35) +- Fix yaml-cpp issues (#39) + + +0.1.0 (2017-11-29) +------------------ +- Don't use forwarding reference (#11) +- Fix overflow bug (#13) +- Set default-constructed timestamp to current time in StartSpan (#18) + + +0.0.8 (2017-11-20) +------------------ +- Fix host IP formatting and improve local IP API (#4) +- Use JSON instead of Thrift's TJSONProtocol (#12) diff --git a/src/jaegertracing/jaeger-client-cpp/CMakeLists.txt b/src/jaegertracing/jaeger-client-cpp/CMakeLists.txt new file mode 100644 index 000000000..42bb7a42a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/CMakeLists.txt @@ -0,0 +1,496 @@ +cmake_minimum_required(VERSION 3.3)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+set(CMAKE_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/cmake/toolchain.cmake"
+ CACHE FILEPATH
+ "Toolchain to use for building this package and dependencies")
+
+set(HUNTER_CONFIGURATION_TYPES "Release;Debug" CACHE STRING
+ "Configuration types used when building Hunter dependencies")
+
+include(CMakeDependentOption)
+include(HunterGate)
+
+option(HUNTER_BUILD_SHARED_LIBS "Build Shared Library" ON)
+
+HunterGate(
+ URL "https://github.com/cpp-pm/hunter/archive/v0.23.249.tar.gz"
+ SHA1 "d45d77d8bba9da13e9290a180e0477e90accd89b"
+ LOCAL # load `${CMAKE_CURRENT_LIST_DIR}/cmake/Hunter/config.cmake`
+)
+
+project(jaegertracing VERSION 0.6.1)
+
+option(JAEGERTRACING_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR
+ CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+ set(cxx_flags -Wall -pedantic)
+ if(JAEGERTRACING_WARNINGS_AS_ERRORS)
+ list(APPEND cxx_flags -Werror)
+ endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+ list(APPEND cxx_flags -Wno-unused-private-field)
+endif()
+
+find_package( Threads )
+list(APPEND link_flags ${CMAKE_THREAD_LIBS_INIT})
+
+if(MSVC)
+ add_definitions(-D_SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING)
+
+ # https://studiofreya.com/2018/01/06/visual-studio-2017-with-cpp17-and-boost/
+ add_definitions(-DBOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE)
+ add_definitions(-D_SCL_SECURE_NO_WARNINGS)
+endif()
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+if(HUNTER_ENABLED)
+ set(hunter_config "CONFIG")
+else()
+ set(hunter_config "")
+endif()
+
+set(package_deps)
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND
+ CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9")
+ message(FATAL_ERROR "Must use gcc >= 4.9")
+endif()
+
+find_package(Boost 1.70 REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
+
+hunter_add_package(thrift)
+find_package(thrift ${hunter_config} REQUIRED)
+if(HUNTER_ENABLED)
+ list(APPEND LIBS thrift::thrift_static)
+else()
+ list(APPEND LIBS ${thrift_LIBRARIES})
+ include_directories(${thrift_INCLUDE_DIR})
+endif()
+list(APPEND package_deps thrift)
+
+
+hunter_add_package(opentracing-cpp)
+# Not `${hunter_config}` because OpenTracing provides its own
+# OpenTracingConfig.cmake file
+find_package(OpenTracing 1.6.0 REQUIRED)
+# Under Windows, link dynamically with OpenTracing
+if (WIN32)
+ list(APPEND LIBS OpenTracing::opentracing)
+ set(OPENTRACING_LIB OpenTracing::opentracing)
+else()
+ list(APPEND LIBS OpenTracing::opentracing-static)
+ set(OPENTRACING_LIB OpenTracing::opentracing-static)
+endif()
+list(APPEND package_deps OpenTracing)
+
+hunter_add_package(nlohmann_json)
+find_package(nlohmann_json 2.1.0 ${hunter_config} REQUIRED)
+include_directories(${nlohmann_json_INCLUDE_DIR})
+list(APPEND package_deps nlohmann_json)
+
+option(JAEGERTRACING_BUILD_EXAMPLES "Build examples" ON)
+
+option(JAEGERTRACING_COVERAGE "Build with coverage" $ENV{COVERAGE})
+option(JAEGERTRACING_BUILD_CROSSDOCK "Build crossdock" $ENV{CROSSDOCK})
+cmake_dependent_option(
+ JAEGERTRACING_WITH_YAML_CPP "Use yaml-cpp to parse config files" ON
+ "NOT JAEGERTRACING_BUILD_CROSSDOCK" ON)
+
+if(JAEGERTRACING_WITH_YAML_CPP)
+ hunter_add_package(yaml-cpp)
+ # Not `${hunter_config}` because yaml-cpp provides its own
+ # yaml-cpp-config.cmake file
+ find_package(yaml-cpp CONFIG REQUIRED)
+ if(HUNTER_ENABLED)
+ list(APPEND LIBS yaml-cpp::yaml-cpp)
+ else()
+ list(APPEND LIBS yaml-cpp)
+ endif()
+ list(APPEND package_deps yaml-cpp)
+endif()
+
+include(CTest)
+if(BUILD_TESTING)
+ hunter_add_package(GTest)
+ find_package(GTest ${hunter_config} REQUIRED)
+
+ if(JAEGERTRACING_COVERAGE)
+ include(CodeCoverage)
+ append_coverage_compiler_flags(cxx_flags)
+ append_coverage_compiler_flags(link_flags)
+ set(COVERAGE_EXCLUDES "${CMAKE_CURRENT_SOURCE_DIR}/src/jaegertracing/thrift-gen/*"
+ "*Test.cpp")
+ endif()
+endif()
+
+set(SRC
+ src/jaegertracing/Config.cpp
+ src/jaegertracing/DynamicLoad.cpp
+ src/jaegertracing/LogRecord.cpp
+ src/jaegertracing/Logging.cpp
+ src/jaegertracing/Reference.cpp
+ src/jaegertracing/Span.cpp
+ src/jaegertracing/SpanContext.cpp
+ src/jaegertracing/Tag.cpp
+ src/jaegertracing/TraceID.cpp
+ src/jaegertracing/Tracer.cpp
+ src/jaegertracing/TracerFactory.cpp
+ src/jaegertracing/Sender.cpp
+ src/jaegertracing/ThriftSender.cpp
+ src/jaegertracing/baggage/BaggageSetter.cpp
+ src/jaegertracing/baggage/RemoteRestrictionJSON.cpp
+ src/jaegertracing/baggage/RemoteRestrictionManager.cpp
+ src/jaegertracing/baggage/Restriction.cpp
+ src/jaegertracing/baggage/RestrictionManager.cpp
+ src/jaegertracing/baggage/RestrictionsConfig.cpp
+ src/jaegertracing/metrics/Counter.cpp
+ src/jaegertracing/metrics/Gauge.cpp
+ src/jaegertracing/metrics/InMemoryStatsReporter.cpp
+ src/jaegertracing/metrics/Metric.cpp
+ src/jaegertracing/metrics/Metrics.cpp
+ src/jaegertracing/metrics/NullCounter.cpp
+ src/jaegertracing/metrics/NullGauge.cpp
+ src/jaegertracing/metrics/NullStatsFactory.cpp
+ src/jaegertracing/metrics/NullStatsReporter.cpp
+ src/jaegertracing/metrics/NullTimer.cpp
+ src/jaegertracing/metrics/StatsFactory.cpp
+ src/jaegertracing/metrics/StatsFactoryImpl.cpp
+ src/jaegertracing/metrics/StatsReporter.cpp
+ src/jaegertracing/metrics/Timer.cpp
+ src/jaegertracing/net/IPAddress.cpp
+ src/jaegertracing/net/Socket.cpp
+ src/jaegertracing/net/URI.cpp
+ src/jaegertracing/net/http/Error.cpp
+ src/jaegertracing/net/http/Header.cpp
+ src/jaegertracing/net/http/Method.cpp
+ src/jaegertracing/net/http/Request.cpp
+ src/jaegertracing/net/http/Response.cpp
+ src/jaegertracing/platform/Endian.cpp
+ src/jaegertracing/platform/Hostname.cpp
+ src/jaegertracing/propagation/Extractor.cpp
+ src/jaegertracing/propagation/HeadersConfig.cpp
+ src/jaegertracing/propagation/Injector.cpp
+ src/jaegertracing/propagation/Propagator.cpp
+ src/jaegertracing/reporters/CompositeReporter.cpp
+ src/jaegertracing/reporters/Config.cpp
+ src/jaegertracing/reporters/InMemoryReporter.cpp
+ src/jaegertracing/reporters/LoggingReporter.cpp
+ src/jaegertracing/reporters/NullReporter.cpp
+ src/jaegertracing/reporters/RemoteReporter.cpp
+ src/jaegertracing/reporters/Reporter.cpp
+ src/jaegertracing/samplers/AdaptiveSampler.cpp
+ src/jaegertracing/samplers/Config.cpp
+ src/jaegertracing/samplers/ConstSampler.cpp
+ src/jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.cpp
+ src/jaegertracing/samplers/ProbabilisticSampler.cpp
+ src/jaegertracing/samplers/RateLimitingSampler.cpp
+ src/jaegertracing/samplers/RemoteSamplingJSON.cpp
+ src/jaegertracing/samplers/RemotelyControlledSampler.cpp
+ src/jaegertracing/samplers/Sampler.cpp
+ src/jaegertracing/samplers/SamplingStatus.cpp
+ src/jaegertracing/thrift-gen/Agent.cpp
+ src/jaegertracing/thrift-gen/AggregationValidator.cpp
+ src/jaegertracing/thrift-gen/BaggageRestrictionManager.cpp
+ src/jaegertracing/thrift-gen/Collector.cpp
+ src/jaegertracing/thrift-gen/Dependency.cpp
+ src/jaegertracing/thrift-gen/SamplingManager.cpp
+ src/jaegertracing/thrift-gen/ZipkinCollector.cpp
+ src/jaegertracing/thrift-gen/agent_constants.cpp
+ src/jaegertracing/thrift-gen/agent_types.cpp
+ src/jaegertracing/thrift-gen/aggregation_validator_constants.cpp
+ src/jaegertracing/thrift-gen/aggregation_validator_types.cpp
+ src/jaegertracing/thrift-gen/baggage_constants.cpp
+ src/jaegertracing/thrift-gen/baggage_types.cpp
+ src/jaegertracing/thrift-gen/dependency_constants.cpp
+ src/jaegertracing/thrift-gen/dependency_types.cpp
+ src/jaegertracing/thrift-gen/jaeger_constants.cpp
+ src/jaegertracing/thrift-gen/jaeger_types.cpp
+ src/jaegertracing/thrift-gen/sampling_constants.cpp
+ src/jaegertracing/thrift-gen/sampling_types.cpp
+ src/jaegertracing/thrift-gen/zipkincore_constants.cpp
+ src/jaegertracing/thrift-gen/zipkincore_types.cpp
+ src/jaegertracing/utils/ErrorUtil.cpp
+ src/jaegertracing/utils/HexParsing.cpp
+ src/jaegertracing/utils/EnvVariable.cpp
+ src/jaegertracing/utils/RateLimiter.cpp
+ src/jaegertracing/utils/UDPTransporter.cpp
+ src/jaegertracing/utils/HTTPTransporter.cpp
+ src/jaegertracing/utils/YAML.cpp
+ src/jaegertracing/ThriftMethods.cpp)
+
+if(JAEGERTRACING_BUILD_CROSSDOCK)
+ list(APPEND SRC
+ src/jaegertracing/thrift-gen/TracedService.cpp
+ src/jaegertracing/thrift-gen/tracetest_constants.cpp
+ src/jaegertracing/thrift-gen/tracetest_types.cpp)
+endif()
+
+function(add_lib_deps lib)
+ target_include_directories(${lib} PUBLIC
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/src>)
+ target_link_libraries(${lib} PUBLIC ${link_flags} ${LIBS})
+ target_compile_options(${lib} PUBLIC ${cxx_flags})
+endfunction()
+
+function(update_path_for_test atest)
+ if(WIN32)
+ # If dependent library is a DLL we have to add location of DLL to PATH
+ set(new_path "")
+
+ foreach(LIB OpenTracing::opentracing yaml-cpp::yaml-cpp GTest::main)
+ list(APPEND new_path $<TARGET_FILE_DIR:${LIB}>)
+ endforeach()
+ list(APPEND new_path $ENV{PATH})
+ string(REPLACE ";" "\\;" new_path "${new_path}")
+
+ set_tests_properties(${atest} PROPERTIES ENVIRONMENT "PATH=${new_path}")
+ endif()
+endfunction()
+
+option(JAEGERTRACING_PLUGIN "Build dynamic plugin" OFF)
+cmake_dependent_option(BUILD_SHARED_LIBS "Build shared libraries" ON
+ "NOT JAEGERTRACING_PLUGIN" OFF)
+
+if(BUILD_SHARED_LIBS)
+ add_library(jaegertracing SHARED ${SRC})
+ if (WIN32)
+ target_compile_definitions(jaegertracing PUBLIC YAML_CPP_DLL)
+ target_link_libraries(jaegertracing PUBLIC Iphlpapi Ws2_32)
+ endif()
+ add_lib_deps(jaegertracing)
+ set_target_properties(jaegertracing PROPERTIES
+ VERSION ${PROJECT_VERSION}
+ SOVERSION ${PROJECT_VERSION_MAJOR})
+ set(JAEGERTRACING_LIB jaegertracing)
+ list(APPEND JAEGERTRACING_LIBS jaegertracing)
+endif()
+
+
+if(JAEGERTRACING_PLUGIN)
+ file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/export.map
+ "{ global: OpenTracingMakeTracerFactory; local: *; };")
+ add_library(jaegertracing_plugin MODULE ${SRC})
+ add_lib_deps(jaegertracing_plugin)
+ target_link_libraries(jaegertracing_plugin PUBLIC
+ -static-libgcc
+ -static-libstdc++
+ -Wl,--version-script=${CMAKE_CURRENT_BINARY_DIR}/export.map)
+endif()
+
+add_library(jaegertracing-static STATIC ${SRC})
+if (NOT WIN32)
+ #on windows, the shared library generate also a .lib file
+ set_target_properties(jaegertracing-static PROPERTIES OUTPUT_NAME jaegertracing)
+endif()
+
+add_lib_deps(jaegertracing-static)
+if (WIN32)
+ target_link_libraries(jaegertracing-static PUBLIC Iphlpapi Ws2_32)
+endif()
+
+if(NOT JAEGERTRACING_LIB)
+ set(JAEGERTRACING_LIB jaegertracing-static)
+endif()
+list(APPEND JAEGERTRACING_LIBS jaegertracing-static)
+
+configure_file(
+ src/jaegertracing/Constants.h.in
+ src/jaegertracing/Constants.h
+ @ONLY)
+
+if(JAEGERTRACING_BUILD_EXAMPLES)
+ add_executable(app examples/App.cpp)
+ target_link_libraries(app PUBLIC ${JAEGERTRACING_LIB})
+endif()
+
+if(BUILD_TESTING)
+ add_library(testutils
+ src/jaegertracing/testutils/TUDPTransport.cpp
+ src/jaegertracing/testutils/SamplingManager.cpp
+ src/jaegertracing/testutils/MockAgent.cpp
+ src/jaegertracing/testutils/TracerUtil.cpp)
+ target_link_libraries(testutils PUBLIC ${JAEGERTRACING_LIB})
+
+ add_executable(UnitTest
+ src/jaegertracing/ConfigTest.cpp
+ src/jaegertracing/ReferenceTest.cpp
+ src/jaegertracing/SpanContextTest.cpp
+ src/jaegertracing/SpanTest.cpp
+ src/jaegertracing/TagTest.cpp
+ src/jaegertracing/TraceIDTest.cpp
+ src/jaegertracing/TracerFactoryTest.cpp
+ src/jaegertracing/TracerTest.cpp
+ src/jaegertracing/ThriftSenderTest.cpp
+ src/jaegertracing/baggage/BaggageTest.cpp
+ src/jaegertracing/metrics/MetricsTest.cpp
+ src/jaegertracing/metrics/NullStatsFactoryTest.cpp
+ src/jaegertracing/net/IPAddressTest.cpp
+ src/jaegertracing/net/SocketTest.cpp
+ src/jaegertracing/net/URITest.cpp
+ src/jaegertracing/net/http/HeaderTest.cpp
+ src/jaegertracing/net/http/MethodTest.cpp
+ src/jaegertracing/net/http/ResponseTest.cpp
+ src/jaegertracing/propagation/PropagatorTest.cpp
+ src/jaegertracing/reporters/ConfigTest.cpp
+ src/jaegertracing/reporters/ReporterTest.cpp
+ src/jaegertracing/samplers/SamplerTest.cpp
+ src/jaegertracing/testutils/MockAgentTest.cpp
+ src/jaegertracing/testutils/TUDPTransportTest.cpp
+ src/jaegertracing/utils/ErrorUtilTest.cpp
+ src/jaegertracing/utils/RateLimiterTest.cpp
+ src/jaegertracing/utils/UDPSenderTest.cpp
+ src/jaegertracing/utils/HTTPTransporterTest.cpp)
+ target_link_libraries(
+ UnitTest PRIVATE testutils PUBLIC GTest::main ${JAEGERTRACING_LIB})
+ add_test(NAME UnitTest COMMAND UnitTest)
+
+ update_path_for_test(UnitTest)
+
+ if(TARGET jaegertracing)
+ add_executable(DynamicallyLoadTracerTest
+ src/jaegertracing/DynamicallyLoadTracerTest.cpp)
+
+ target_include_directories(DynamicallyLoadTracerTest PUBLIC
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/src>)
+ target_link_libraries(
+ DynamicallyLoadTracerTest ${OPENTRACING_LIB} GTest::main)
+ add_test(NAME DynamicallyLoadTracerTest
+ COMMAND DynamicallyLoadTracerTest $<TARGET_FILE:jaegertracing>)
+ update_path_for_test(DynamicallyLoadTracerTest)
+ if(JAEGERTRACING_COVERAGE)
+ setup_target_for_coverage(NAME UnitTestCoverage
+ EXECUTABLE UnitTest
+ DEPENDENCIES UnitTest)
+ endif()
+ endif()
+endif()
+
+
+
+if(JAEGERTRACING_BUILD_CROSSDOCK)
+ set(CROSSDOCK_SRC crossdock/Server.cpp)
+ add_executable(crossdock ${CROSSDOCK_SRC})
+ target_include_directories(crossdock PUBLIC
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/crossdock>)
+ target_link_libraries(crossdock PUBLIC ${JAEGERTRACING_LIB})
+
+ string(CONCAT JAEGER_CROSSDOCK_URL
+ "https://raw.githubusercontent.com/"
+ "jaegertracing/jaeger/master/docker-compose/jaeger-docker-compose.yml")
+ file(DOWNLOAD ${JAEGER_CROSSDOCK_URL}
+ "${CMAKE_CURRENT_SOURCE_DIR}/crossdock/jaeger-docker-compose.yml")
+ find_program(DOCKER_COMPOSE_EXE docker-compose REQUIRED)
+ set(DOCKER_COMPOSE_CMD ${DOCKER_COMPOSE_EXE}
+ -f ${CMAKE_CURRENT_SOURCE_DIR}/crossdock/docker-compose.yml
+ -f ${CMAKE_CURRENT_SOURCE_DIR}/crossdock/jaeger-docker-compose.yml)
+ add_custom_target(crossdock-kill
+ COMMAND ${DOCKER_COMPOSE_CMD} down)
+ add_custom_target(crossdock-run
+ COMMAND ${DOCKER_COMPOSE_CMD} build
+ COMMAND ${DOCKER_COMPOSE_CMD} run crossdock
+ DEPENDS crossdock-kill
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+ add_custom_target(crossdock-fresh
+ COMMAND ${DOCKER_COMPOSE_CMD} build --pull --no-cache
+ COMMAND ${DOCKER_COMPOSE_CMD} run crossdock
+ DEPENDS crossdock-kill
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+ add_custom_target(crossdock-logs
+ COMMAND ${DOCKER_COMPOSE_CMD} logs)
+endif()
+
+
+
+# Installation (https://github.com/forexample/package-example)
+
+# Introduce variables:
+# * CMAKE_INSTALL_LIBDIR
+# * CMAKE_INSTALL_BINDIR
+# * CMAKE_INSTALL_INCLUDEDIR
+include(GNUInstallDirs)
+
+# Layout. This works for all platforms:
+# * <prefix>/lib*/cmake/<PROJECT-NAME>
+# * <prefix>/lib*/
+# * <prefix>/include/
+set(config_install_dir "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
+
+set(generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
+
+# Configuration
+set(version_config "${generated_dir}/${PROJECT_NAME}ConfigVersion.cmake")
+set(project_config "${generated_dir}/${PROJECT_NAME}Config.cmake")
+set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
+set(namespace "${PROJECT_NAME}::")
+
+# Include module with fuction 'write_basic_package_version_file'
+include(CMakePackageConfigHelpers)
+
+# Configure '<PROJECT-NAME>ConfigVersion.cmake'
+# Use:
+# * PROJECT_VERSION
+write_basic_package_version_file(
+ "${version_config}" COMPATIBILITY SameMajorVersion
+)
+
+# Configure '<PROJECT-NAME>Config.cmake'
+# Use variables:
+# * TARGETS_EXPORT_NAME
+# * PROJECT_NAME
+configure_package_config_file(
+ "cmake/Config.cmake.in"
+ "${project_config}"
+ INSTALL_DESTINATION "${config_install_dir}"
+)
+
+# Targets:
+# * <prefix>/lib*/libjaegertracing.a
+# * <prefix>/lib*/libjaegertracing.so
+# * header location after install: <prefix>/include/jaegertracing/Tracer.h
+# * headers can be included by C++ code `#include <jaegertracing/Tracer.h>`
+install(
+ TARGETS ${JAEGERTRACING_LIBS}
+ EXPORT "${TARGETS_EXPORT_NAME}"
+ LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+ ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+ RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+ INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+# Headers:
+# * src/jaegertracing/Tracer.h -> <prefix>/include/jaegertracing/Tracer.h
+install(DIRECTORY "src/jaegertracing"
+ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+ FILES_MATCHING
+ PATTERN "*.h"
+ PATTERN "testutils/*.h" EXCLUDE)
+
+# * build/src/jaegertracing/Constants.h ->
+# <prefix>/include/jaegertracing/Constants.h
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/src/jaegertracing/Constants.h"
+ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/jaegertracing")
+
+# Config
+# * <prefix>/lib*/cmake/jaegertracing/jaegertracingConfig.cmake
+# * <prefix>/lib*/cmake/jaegertracing/jaegertracingConfigVersion.cmake
+install(
+ FILES "${project_config}" "${version_config}"
+ DESTINATION "${config_install_dir}"
+)
+
+# Config
+# * <prefix>/lib*/cmake/jaegertracing/jaegertracingTargets.cmake
+install(
+ EXPORT "${TARGETS_EXPORT_NAME}"
+ NAMESPACE "${namespace}"
+ DESTINATION "${config_install_dir}"
+)
diff --git a/src/jaegertracing/jaeger-client-cpp/CONTRIBUTING.md b/src/jaegertracing/jaeger-client-cpp/CONTRIBUTING.md new file mode 100644 index 000000000..11d07c887 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/CONTRIBUTING.md @@ -0,0 +1,117 @@ +# How to Contribute to Jaeger + +We'd love your help! + +Jaeger is [Apache 2.0 licensed](LICENSE) and accepts contributions via GitHub +pull requests. This document outlines some of the conventions on development +workflow, commit message formatting, contact points and other resources to make +it easier to get your contribution accepted. + +We gratefully welcome improvements to documentation as well as to code. + +## Making A Change + +*Before making any significant changes, please [open an issue](https://github.com/jaegertracing/jaeger-client-cpp/issues).* +Discussing your proposed changes ahead of time will make the contribution process smooth for everyone. + +Once we've discussed your changes and you've got your code ready, make sure +that tests are passing and open your pull request. Your pull request is most likely to be accepted if it: + +* Includes tests for new functionality. +* Follows the code style guidelines. +* Has a [good commit message](https://chris.beams.io/posts/git-commit/): + * Separate subject from body with a blank line + * Limit the subject line to 50 characters + * Capitalize the subject line + * Do not end the subject line with a period + * Use the imperative mood in the subject line + * Wrap the body at 72 characters + * Use the body to explain _what_ and _why_ instead of _how_ +* Each commit is signed by the author ([see below](#sign-your-work)). + +## License and Certificate of Origin + +By contributing to this project you agree to license your contribution under the terms +of the [Apache License](LICENSE), and you agree to the [Developer Certificate of +Origin](https://developercertificate.org/) (DCO). This document was created +by the Linux Kernel community and is a simple statement that you, as a +contributor, have the legal right to make the contribution. See the [DCO](DCO) +file for details. + +``` +/* + * Copyright (c) 2018, The Jaeger Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License + * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express + * or implied. See the License for the specific language governing permissions and limitations under + * the License. + */ +``` + +## Sign your work + +The sign-off is a simple line at the end of the explanation for the +patch, which certifies that you wrote it or otherwise have the right to +pass it on as an open-source patch. The rules are pretty simple: if you +can certify the below (from +[developercertificate.org](http://developercertificate.org/)): + +``` +Developer Certificate of Origin +Version 1.1 + +Copyright (C) 2004, 2006 The Linux Foundation and its contributors. +660 York Street, Suite 102, +San Francisco, CA 94110 USA + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + + +Developer's Certificate of Origin 1.1 + +By making a contribution to this project, I certify that: + +(a) The contribution was created in whole or in part by me and I + have the right to submit it under the open source license + indicated in the file; or + +(b) The contribution is based upon previous work that, to the best + of my knowledge, is covered under an appropriate open source + license and I have the right under that license to submit that + work with modifications, whether created in whole or in part + by me, under the same open source license (unless I am + permitted to submit under a different license), as indicated + in the file; or + +(c) The contribution was provided directly to me by some other + person who certified (a), (b) or (c) and I have not modified + it. + +(d) I understand and agree that this project and the contribution + are public and that a record of the contribution (including all + personal information I submit with it, including my sign-off) is + maintained indefinitely and may be redistributed consistent with + this project or the open source license(s) involved. +``` + +then you just add a line to every git commit message: + + Signed-off-by: Joe Smith <joe@gmail.com> + +using your real name (sorry, no pseudonyms or anonymous contributions.) + +You can add the sign off when creating the git commit via `git commit -s`. + +If you want this to be automatic you can set up some aliases: + +``` +git config --add alias.amend "commit -s --amend" +git config --add alias.c "commit -s" +``` diff --git a/src/jaegertracing/jaeger-client-cpp/Dockerfile.plugin b/src/jaegertracing/jaeger-client-cpp/Dockerfile.plugin new file mode 100644 index 000000000..996810ed8 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/Dockerfile.plugin @@ -0,0 +1,9 @@ +FROM debian +RUN apt-get update +RUN apt-get install --yes build-essential curl git +RUN curl -L -O "https://cmake.org/files/v3.11/cmake-3.11.0-Linux-x86_64.sh" && \ + bash cmake-3.11.0-Linux-x86_64.sh --skip-license + +ADD . /src/jaeger-cpp-client +WORKDIR /src/jaeger-cpp-client +RUN ./scripts/build-plugin.sh diff --git a/src/jaegertracing/jaeger-client-cpp/LICENSE b/src/jaegertracing/jaeger-client-cpp/LICENSE new file mode 100644 index 000000000..8dada3eda --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/src/jaegertracing/jaeger-client-cpp/README.md b/src/jaegertracing/jaeger-client-cpp/README.md new file mode 100644 index 000000000..566fd2481 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/README.md @@ -0,0 +1,135 @@ +[![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov] [![Appveyor Build][appveyor]][appveyor] [![OpenTracing 1.0 Enabled][ot-img]][ot-url] + +# jaeger-client-cpp +[Jaeger](https://www.jaegertracing.io/) SDK with [OpenTracing API for C++](https://github.com/opentracing/opentracing-cpp) binding. + +## Contributing + +Please see [CONTRIBUTING.md](CONTRIBUTING.md). + +## Building + +jaeger-client-cpp is built using CMake. It will automatically download +needed dependencies using [Hunter](https://docs.hunter.sh/en/latest/). + +To build: + +```bash + mkdir build + cd build + cmake .. + make +``` + +After building, the [example](./examples/App.cpp) program can be run +with: + +```bash + ./app ../examples/config.yml +``` + +To run tests: + +```bash + make test +``` + +To install the library: + +```bash + make install +``` + +### Generated files + +This project uses Apache Thrift for wire-format protocol support code +generation. It currently requires Thrift 0.11.0. + +The code can be re-generated with + +```bash + $ git submodule update --init + $ find idl/thrift/ -type f -name \*.thrift -exec thrift -gen cpp -out src/jaegertracing/thrift-gen {} \; + $ git apply scripts/thrift-gen.patch +``` + +### Updating Agent Host and Port + +The default host and port for Jaeger Agent is `127.0.0.1:6831`. When the application and Jaeger Agent are running in different containers on the same host, the application's notion of `localhost`/127.0.0.1 it restriced to its own container, so in this case it's usually necessary to override the Agent's host/port by updating your reporter configuration: + +YAML configuration: + +```yml +reporter: + localAgentHostPort: jaeger-agent:6831 +``` + +NOTE: It is not recommended to use a remote host for UDP connections. + +### Connecting directly to the Collector + +In case the client should connect directly to the collector instead of going through an agent, it's necessary update the reporter configuration + +```yml +reporter: + endpoint: http://${collectorhost}:${collectorport}/api/traces +``` + +Note that if both `localAgentHostPort` and `endpoint` are specified, the `endpoint` will be used. + +### Updating Sampling Server URL + +The default sampling collector URL is `http://127.0.0.1:5778/sampling`. Similar to UDP address above, you can use a different URL by updating the sampler configuration. + +```yml +sampler: + samplingServerURL: http://jaeger-agent.local:5778/sampling +``` + +### Configuration via Environment + +It's possible to populate the tracer configuration from the environement variables by calling `jaegertracing::Config::fromEnv`. + +The following property names are currently available: + +Property | Description +--- | --- +JAEGER_SERVICE_NAME | The service name +JAEGER_DISABLED _(not recommended)_ | Instructs the Configuration to return a no-op tracer +JAEGER_AGENT_HOST | The hostname for communicating with agent via UDP +JAEGER_AGENT_PORT | The port for communicating with agent via UDP +JAEGER_ENDPOINT | The traces endpoint, in case the client should connect directly to the Collector, like http://jaeger-collector:14268/api/traces +JAEGER_REPORTER_LOG_SPANS | Whether the reporter should also log the spans +JAEGER_REPORTER_MAX_QUEUE_SIZE | The reporter's maximum queue size +JAEGER_REPORTER_FLUSH_INTERVAL | The reporter's flush interval (ms) +JAEGER_SAMPLER_TYPE | The [sampler type](https://www.jaegertracing.io/docs/latest/sampling/#client-sampling-configuration) +JAEGER_SAMPLER_PARAM | The sampler parameter (double) +JAEGER_SAMPLING_ENDPOINT | The url for the remote sampling conf when using sampler type remote. Default is http://127.0.0.1:5778/sampling +JAEGER_TAGS | A comma separated list of `name = value` tracer level tags, which get added to all reported spans. The value can also refer to an environment variable using the format `${envVarName:default}`, where the `:default` is optional, and identifies a value to be used if the environment variable cannot be found + +### SelfRef +Jaeger Tracer supports an additional reference type call 'SelfRef'. +It returns an opentracing::SpanReference which can be passed to Tracer::StartSpan +to influence the SpanContext of the newly created span. Specifically, the new span inherits the traceID +and spanID from the passed SELF reference. It can be used to pass externally generated IDs to the tracer, +with the purpose of recording spans from data generated elsewhere (e.g. from logs), or by augmenting the +data of the existing span (Jaeger backend will merge multiple instances of the spans with the same IDs). +Must be the lone reference, can be used only for root spans. + +Usage example: +``` + jaegertracing::SpanContext customCtx { {1, 2}, 3, 0, 0, jaegertracing::SpanContext::StrMap() }; // TraceId and SpanID must be != 0 + auto span = tracer->StartSpan("spanName", { jaegertracing::SelfRef(&customCtx) }); +``` + +## License + +[Apache 2.0 License](./LICENSE). + +[ci-img]: https://travis-ci.org/jaegertracing/jaeger-client-cpp.svg?branch=master +[ci]: https://travis-ci.org/jaegertracing/jaeger-client-cpp +[appveyor]: https://ci.appveyor.com/api/projects/status/bu992qd3y9bpwe7u?svg=true +[cov-img]: https://codecov.io/gh/jaegertracing/jaeger-client-cpp/branch/master/graph/badge.svg +[cov]: https://codecov.io/gh/jaegertracing/jaeger-client-cpp +[ot-img]: https://img.shields.io/badge/OpenTracing--1.0-enabled-blue.svg +[ot-url]: http://opentracing.io diff --git a/src/jaegertracing/jaeger-client-cpp/RELEASE.md b/src/jaegertracing/jaeger-client-cpp/RELEASE.md new file mode 100644 index 000000000..9cd2d1231 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/RELEASE.md @@ -0,0 +1,10 @@ +# Release Process + +1. Create a PR "Preparing for release X.Y.Z" against master branch + * Alter CHANGELOG.md from `<placeholder_version> (unreleased)` to `<X.Y.Z> (YYYY-MM-DD)` +2. Create a release "Release X.Y.Z" on Github + * Create Tag `vX.Y.Z` + * Copy CHANGELOG.md into the release notes +3. Create a PR "Back to development" against master branch + * Add `<next_version> (unreleased)` to CHANGELOG.md + * Update project version in CMakeLists.txt to the `<next version>` diff --git a/src/jaegertracing/jaeger-client-cpp/cmake/CodeCoverage.cmake b/src/jaegertracing/jaeger-client-cpp/cmake/CodeCoverage.cmake new file mode 100644 index 000000000..85261fc36 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/cmake/CodeCoverage.cmake @@ -0,0 +1,180 @@ +# Copyright (c) 2012 - 2017, Lars Bilke +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors +# may be used to endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# CHANGES: +# +# 2012-01-31, Lars Bilke +# - Enable Code Coverage +# +# 2013-09-17, Joakim Söderberg +# - Added support for Clang. +# - Some additional usage instructions. +# +# 2016-02-03, Lars Bilke +# - Refactored functions to use named parameters +# +# 2017-06-02, Lars Bilke +# - Merged with modified version from github.com/ufz/ogs +# +# +# USAGE: +# +# 1. Copy this file into your cmake modules path. +# +# 2. Add the following line to your CMakeLists.txt: +# include(CodeCoverage) +# +# 3. Append necessary compiler flags: +# APPEND_COVERAGE_COMPILER_FLAGS() +# +# 4. If you need to exclude additional directories from the report, specify them +# using the COVERAGE_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE. +# Example: +# set(COVERAGE_EXCLUDES 'dir1/*' 'dir2/*') +# +# 5. Use the functions described below to create a custom make target which +# runs your test executable and produces a code coverage report. +# +# 6. Build a Debug build: +# cmake -DCMAKE_BUILD_TYPE=Debug .. +# make +# make my_coverage_target +# + +include(CMakeParseArguments) + +# Check prereqs +find_program( GCOV_PATH gcov ) +find_program( LCOV_PATH lcov ) +find_program( GENHTML_PATH genhtml ) +find_program( SIMPLE_PYTHON_EXECUTABLE python ) + +if(NOT GCOV_PATH) + message(FATAL_ERROR "gcov not found! Aborting...") +endif() # NOT GCOV_PATH + +if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang") + if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3) + message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...") + endif() + list(APPEND COVERAGE_COMPILER_FLAGS -Qunused-arguments) +elseif(NOT CMAKE_COMPILER_IS_GNUCXX) + message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") +endif() + +list(APPEND COVERAGE_COMPILER_FLAGS + -g -O0 --coverage -fprofile-arcs -ftest-coverage) +set(COVERAGE_COMPILER_FLAGS ${COVERAGE_COMPILER_FLAGS} CACHE INTERNAL "") + +set(CMAKE_CXX_FLAGS_COVERAGE + ${COVERAGE_COMPILER_FLAGS} + CACHE STRING "Flags used by the C++ compiler during coverage builds." + FORCE ) +set(CMAKE_C_FLAGS_COVERAGE + ${COVERAGE_COMPILER_FLAGS} + CACHE STRING "Flags used by the C compiler during coverage builds." + FORCE ) +set(CMAKE_EXE_LINKER_FLAGS_COVERAGE + "" + CACHE STRING "Flags used for linking binaries during coverage builds." + FORCE ) +set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE + "" + CACHE STRING "Flags used by the shared libraries linker during coverage builds." + FORCE ) +mark_as_advanced( + CMAKE_CXX_FLAGS_COVERAGE + CMAKE_C_FLAGS_COVERAGE + CMAKE_EXE_LINKER_FLAGS_COVERAGE + CMAKE_SHARED_LINKER_FLAGS_COVERAGE ) + +if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug") + message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading") +endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug" + +if(CMAKE_C_COMPILER_ID STREQUAL "GNU") + link_libraries(gcov) +else() + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage") +endif() + +# Defines a target for running and collection code coverage information +# Builds dependencies, runs the given executable and outputs reports. +# NOTE! The executable should always have a ZERO as exit code otherwise +# the coverage generation will not complete. +# +# setup_target_for_coverage( +# NAME testrunner_coverage # New target name +# EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR +# DEPENDENCIES testrunner # Dependencies to build first +# ) +function(setup_target_for_coverage) + set(options NONE) + set(oneValueArgs NAME) + set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(NOT LCOV_PATH) + message(FATAL_ERROR "lcov not found! Aborting...") + endif() # NOT LCOV_PATH + + if(NOT GENHTML_PATH) + message(FATAL_ERROR "genhtml not found! Aborting...") + endif() # NOT GENHTML_PATH + + # Setup target + add_custom_target(${Coverage_NAME} + + # Cleanup lcov + COMMAND ${LCOV_PATH} --directory . --zerocounters + + # Run tests + COMMAND ${Coverage_EXECUTABLE} + + # Capturing lcov counters and generating report + COMMAND ${LCOV_PATH} --base-directory ${CMAKE_SOURCE_DIR} --directory . --capture --output-file ${Coverage_NAME}.info --no-external + COMMAND ${LCOV_PATH} --remove ${Coverage_NAME}.info ${COVERAGE_EXCLUDES} --output-file ${Coverage_NAME}.info.cleaned + COMMAND ${GENHTML_PATH} --legend --demangle-cpp -o ${Coverage_NAME} ${Coverage_NAME}.info.cleaned + COMMAND ${CMAKE_COMMAND} -E rename ${Coverage_NAME}.info.cleaned coverage.info + COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.info + + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." + ) + + # Show info where to find the report + add_custom_command(TARGET ${Coverage_NAME} POST_BUILD + COMMAND ; + COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." + ) +endfunction() # setup_target_for_coverage + +function(append_coverage_compiler_flags flags_var) + set(${flags_var} ${${flags_var}} ${COVERAGE_COMPILER_FLAGS} PARENT_SCOPE) +endfunction() # append_coverage_compiler_flags diff --git a/src/jaegertracing/jaeger-client-cpp/cmake/Config.cmake.in b/src/jaegertracing/jaeger-client-cpp/cmake/Config.cmake.in new file mode 100644 index 000000000..c2a892b04 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/cmake/Config.cmake.in @@ -0,0 +1,20 @@ +@PACKAGE_INIT@ + +set(package_deps @package_deps@) +foreach(dep IN LISTS package_deps) + if(dep STREQUAL "OpenSSL" OR dep STREQUAL "Threads") + find_package(${dep} REQUIRED) + elseif(dep STREQUAL "OpenTracing" OR + dep STREQUAL "yaml-cpp") + find_package(${dep} CONFIG REQUIRED) + else() + find_package(${dep} @hunter_config@ REQUIRED) + endif() +endforeach() + +set(boost_components @boost_components@) +find_package(Boost CONFIG REQUIRED ${boost_components}) + +check_required_components("@PROJECT_NAME@") + +include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake") diff --git a/src/jaegertracing/jaeger-client-cpp/cmake/FindOpenTracing.cmake b/src/jaegertracing/jaeger-client-cpp/cmake/FindOpenTracing.cmake new file mode 100644 index 000000000..79413d17e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/cmake/FindOpenTracing.cmake @@ -0,0 +1,95 @@ +#.rst: +# FindOpenTracing +# ------------ +# +# This module finds the `OpenTracing` library. +# +# Imported target +# ^^^^^^^^^^^^^^^ +# +# This module defines the following :prop_tgt:`IMPORTED` target: +# +# ``OpenTracing`` +# The Opentracing library, if found +# +# Result variables +# ^^^^^^^^^^^^^^^^ +# +# This module sets the following +# +# ``OpenTracing_FOUND`` +# ``TRUE`` if system has OpenTracing +# ``OpenTracing_INCLUDE_DIRS`` +# The OpenTracing include directories +# ``OpenTracing_LIBRARIES`` +# The libraries needed to use OpenTracing +# ``OpenTracing_VERSION_STRING`` +# The OpenTracing version + +#============================================================================= +# Copyright 2018 Mania Abdi, Inc. +# Copyright 2018 Mania Abdi +# +# Distributed under the OSI-approved BSD License (the "License"); +# see accompanying file Copyright.txt for details. +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the License for more information. +#============================================================================= +# (To distribute this file outside of CMake, substitute the full +# License text for the above reference.) + +find_path(OpenTracing_INCLUDE_DIRS + NAMES opentracing/tracer.h + HINTS + ${OpenTracing_HOME} + ENV OpenTracing_HOME + PATH_SUFFIXES + include + ) +message(STATUS "OpenTracing_INCLUDE_DIRS ${OpenTracing_INCLUDE_DIRS}") +find_library(OpenTracing_LIBRARIES NAMES + opentracing libopentracing + HINTS + ${OpenTracing_HOME} + ENV OpenTracing_HOME + PATH_SUFFIXES + lib lib64 + ) +message(STATUS "opentracing libraries ${OpenTracing_LIBRARIES}") + +if(OpenTracing_INCLUDE_DIRS AND OpenTracing_LIBRARIES) + + # will need specifically 1.5.x for successful working with Jaeger + set(OpenTracing_VERSION_STRING "1.6.0") + + if(NOT TARGET OpenTracing::opentracing) + add_library(OpenTracing::opentracing SHARED IMPORTED) + set_target_properties(OpenTracing::opentracing PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${OpenTracing_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES ${CMAKE_DL_LIBS} + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${OpenTracing_LIBRARIES}") + endif() + + if(NOT TARGET OpenTracing::opentracing-static) + add_library(OpenTracing::opentracing-static STATIC IMPORTED) + set_target_properties(OpenTracing::opentracing-static PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${OpenTracing_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES ${CMAKE_DL_LIBS} + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${OpenTracing_LIBRARIES}") + endif() + message(STATUS "include opentracing ${OpenTracing_INCLUDE_DIRS}") + + # add libdl to required libraries + set(OpenTracing_LIBRARIES ${OpenTracing_LIBRARIES} ${CMAKE_DL_LIBS}) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(OpenTracing FOUND_VAR OpenTracing_FOUND + REQUIRED_VARS OpenTracing_LIBRARIES + OpenTracing_INCLUDE_DIRS + VERSION_VAR OpenTracing_VERSION_STRING) +mark_as_advanced(OpenTracing_LIBRARIES OpenTracing_INCLUDE_DIRS) diff --git a/src/jaegertracing/jaeger-client-cpp/cmake/Findnlohmann_json.cmake b/src/jaegertracing/jaeger-client-cpp/cmake/Findnlohmann_json.cmake new file mode 100644 index 000000000..c5fc8b048 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/cmake/Findnlohmann_json.cmake @@ -0,0 +1,55 @@ +# - Try to find nlohmann_json +# +# The following variables are optionally searched for defaults +# nlohmann_json_ROOT_DIR: Base directory where all GLOG components are found +# +# The following are set after configuration is done: +# nlohmann_json_FOUND +# nlohmann_json_INCLUDE_DIRS +# nlohmann_json_LIBRARIES + +include(FindPackageHandleStandardArgs) + +# only look in default directories +set(nlohmann_json_INCLUDE_NAME "nlohmann/json.hpp") + +find_path(nlohmann_json_INCLUDE_DIR + NAMES + nlohmann/json.hpp + PATHS /usr/local/include + /usr/include) + +if (NOT nlohmann_json_INCLUDE_DIR) + set(nlohmann_json_INCLUDE_NAME "json.hpp") + find_path( + nlohmann_json_INCLUDE_DIR + NAMES "${nlohmann_json_INCLUDE_NAME}" + ) +endif() + + +# Version detection. Unfortunately the header doesn't expose a proper version +# define. +if (nlohmann_json_INCLUDE_DIR AND nlohmann_json_INCLUDE_NAME) + file(READ "${nlohmann_json_INCLUDE_DIR}/${nlohmann_json_INCLUDE_NAME}" NL_HDR_TXT LIMIT 1000) + if (NL_HDR_TXT MATCHES "version ([0-9]+\.[0-9]+\.[0-9]+)") + set(nlohmann_json_VERSION "${CMAKE_MATCH_1}") + endif() +endif() + +set(nlohmann_json_VERSION "${nlohmann_json_VERSION}" CACHE STRING "nlohmann header version") + +# handle the QUIETLY and REQUIRED arguments and set nlohmann_json_FOUND to TRUE +# if all listed variables are TRUE, hide their existence from configuration view +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args( + nlohmann_json + REQUIRED_VARS nlohmann_json_INCLUDE_DIR nlohmann_json_INCLUDE_NAME + VERSION_VAR nlohmann_json_VERSION) + +if(nlohmann_json_FOUND AND NOT (TARGET nlohmann_json)) + add_library(nlohmann_json SHARED IMPORTED) + set_target_properties(nlohmann_json PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${nlohmann_json_INCLUDE_DIR}" + ) +endif() diff --git a/src/jaegertracing/jaeger-client-cpp/cmake/Findthrift.cmake b/src/jaegertracing/jaeger-client-cpp/cmake/Findthrift.cmake new file mode 100644 index 000000000..77c36ed97 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/cmake/Findthrift.cmake @@ -0,0 +1,93 @@ +# https://github.com/snikulov/cmake-modules/blob/master/FindThrift.cmake + +# - Find Thrift (a cross platform RPC lib/tool) +# This module defines +# thrift_VERSION_STRING, version string of ant if found +# thrift_LIBRARIES, libraries to link +# thrift_INCLUDE_DIR, where to find thrift headers +# thrift_COMPILER, thrift compiler executable +# thrift_FOUND, If false, do not try to use ant +# Function +# thrift_gen_cpp(<path to thrift file> <output variable with file list>) +# +# Initial work was done by Cloudera https://github.com/cloudera/Impala +# 2014 - modified by snikulov + +# prefer the thrift version supplied in thrift_HOME (cmake -Dthrift_HOME then environment) +find_path(thrift_INCLUDE_DIR + NAMES + thrift/Thrift.h + HINTS + ${thrift_HOME} + ENV thrift_HOME + /usr/local + /opt/local + PATH_SUFFIXES + include +) + +# prefer the thrift version supplied in thrift_HOME +find_library(thrift_LIBRARIES + NAMES + thrift libthrift + HINTS + ${thrift_HOME} + ENV thrift_HOME + /usr/local + /opt/local + PATH_SUFFIXES + lib lib64 +) + +find_program(thrift_COMPILER + NAMES + thrift + HINTS + ${thrift_HOME} + ENV thrift_HOME + /usr/local + /opt/local + PATH_SUFFIXES + bin bin64 +) + +if (thrift_COMPILER) + exec_program(${thrift_COMPILER} + ARGS -version OUTPUT_VARIABLE __thrift_OUT RETURN_VALUE thrift_RETURN) + string(REGEX MATCH "[0-9]+.[0-9]+.[0-9]+-[a-z]+$" thrift_VERSION_STRING ${__thrift_OUT}) + + # define utility function to generate cpp files + function(thrift_gen_cpp thrift_file thrift_CPP_FILES_LIST thrift_GEN_INCLUDE_DIR) + set(_res) + set(_res_inc_path) + if(EXISTS ${thrift_file}) + get_filename_component(_target_dir ${thrift_file} NAME_WE) + message("thrif_gen_cpp: ${thrift_file}") + + if(NOT EXISTS ${CMAKE_BINARY_DIR}/${_target_dir}) + file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/${_target_dir}) + endif() + exec_program(${thrift_COMPILER} + ARGS -o "${CMAKE_BINARY_DIR}/${_target_dir}" --gen cpp ${thrift_file} + OUTPUT_VARIABLE __thrift_OUT + RETURN_VALUE thrift_RETURN) + file(GLOB_RECURSE __result_src "${CMAKE_BINARY_DIR}/${_target_dir}/*.cpp") + file(GLOB_RECURSE __result_hdr "${CMAKE_BINARY_DIR}/${_target_dir}/*.h") + list(APPEND _res ${__result_src}) + list(APPEND _res ${__result_hdr}) + if(__result_hdr) + list(GET __result_hdr 0 _res_inc_path) + get_filename_component(_res_inc_path ${_res_inc_path} DIRECTORY) + endif() + else() + message("thrift_gen_cpp: file ${thrift_file} does not exists") + endif() + set(${thrift_CPP_FILES_LIST} "${_res}" PARENT_SCOPE) + set(${thrift_GEN_INCLUDE_DIR} "${_res_inc_path}" PARENT_SCOPE) + endfunction() +endif () + + +include(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(thrift DEFAULT_MSG thrift_LIBRARIES thrift_INCLUDE_DIR thrift_COMPILER) +mark_as_advanced(thrift_LIBRARIES thrift_INCLUDE_DIR thrift_COMPILER thrift_VERSION_STRING) diff --git a/src/jaegertracing/jaeger-client-cpp/cmake/Hunter/config.cmake b/src/jaegertracing/jaeger-client-cpp/cmake/Hunter/config.cmake new file mode 100644 index 000000000..f26c8530c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/cmake/Hunter/config.cmake @@ -0,0 +1 @@ +hunter_config(GTest VERSION 1.8.0-hunter-p11) diff --git a/src/jaegertracing/jaeger-client-cpp/cmake/HunterGate.cmake b/src/jaegertracing/jaeger-client-cpp/cmake/HunterGate.cmake new file mode 100644 index 000000000..c24c0e577 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/cmake/HunterGate.cmake @@ -0,0 +1,543 @@ +# Copyright (c) 2013-2017, Ruslan Baratov +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# This is a gate file to Hunter package manager. +# Include this file using `include` command and add package you need, example: +# +# cmake_minimum_required(VERSION 3.0) +# +# include("cmake/HunterGate.cmake") +# HunterGate( +# URL "https://github.com/path/to/hunter/archive.tar.gz" +# SHA1 "798501e983f14b28b10cda16afa4de69eee1da1d" +# ) +# +# project(MyProject) +# +# hunter_add_package(Foo) +# hunter_add_package(Boo COMPONENTS Bar Baz) +# +# Projects: +# * https://github.com/hunter-packages/gate/ +# * https://github.com/ruslo/hunter + +option(HUNTER_ENABLED "Enable Hunter package manager support" ON) +if(HUNTER_ENABLED) + if(CMAKE_VERSION VERSION_LESS "3.0") + message(FATAL_ERROR "At least CMake version 3.0 required for hunter dependency management." + " Update CMake or set HUNTER_ENABLED to OFF.") + endif() +endif() + +include(CMakeParseArguments) # cmake_parse_arguments + +option(HUNTER_STATUS_PRINT "Print working status" ON) +option(HUNTER_STATUS_DEBUG "Print a lot info" OFF) +option(HUNTER_TLS_VERIFY "Enable/disable TLS certificate checking on downloads" ON) + +set(HUNTER_WIKI "https://github.com/ruslo/hunter/wiki") + +function(hunter_gate_status_print) + foreach(print_message ${ARGV}) + if(HUNTER_STATUS_PRINT OR HUNTER_STATUS_DEBUG) + message(STATUS "[hunter] ${print_message}") + endif() + endforeach() +endfunction() + +function(hunter_gate_status_debug) + foreach(print_message ${ARGV}) + if(HUNTER_STATUS_DEBUG) + string(TIMESTAMP timestamp) + message(STATUS "[hunter *** DEBUG *** ${timestamp}] ${print_message}") + endif() + endforeach() +endfunction() + +function(hunter_gate_wiki wiki_page) + message("------------------------------ WIKI -------------------------------") + message(" ${HUNTER_WIKI}/${wiki_page}") + message("-------------------------------------------------------------------") + message("") + message(FATAL_ERROR "") +endfunction() + +function(hunter_gate_internal_error) + message("") + foreach(print_message ${ARGV}) + message("[hunter ** INTERNAL **] ${print_message}") + endforeach() + message("[hunter ** INTERNAL **] [Directory:${CMAKE_CURRENT_LIST_DIR}]") + message("") + hunter_gate_wiki("error.internal") +endfunction() + +function(hunter_gate_fatal_error) + cmake_parse_arguments(hunter "" "WIKI" "" "${ARGV}") + string(COMPARE EQUAL "${hunter_WIKI}" "" have_no_wiki) + if(have_no_wiki) + hunter_gate_internal_error("Expected wiki") + endif() + message("") + foreach(x ${hunter_UNPARSED_ARGUMENTS}) + message("[hunter ** FATAL ERROR **] ${x}") + endforeach() + message("[hunter ** FATAL ERROR **] [Directory:${CMAKE_CURRENT_LIST_DIR}]") + message("") + hunter_gate_wiki("${hunter_WIKI}") +endfunction() + +function(hunter_gate_user_error) + hunter_gate_fatal_error(${ARGV} WIKI "error.incorrect.input.data") +endfunction() + +function(hunter_gate_self root version sha1 result) + string(COMPARE EQUAL "${root}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("root is empty") + endif() + + string(COMPARE EQUAL "${version}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("version is empty") + endif() + + string(COMPARE EQUAL "${sha1}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("sha1 is empty") + endif() + + string(SUBSTRING "${sha1}" 0 7 archive_id) + + if(EXISTS "${root}/cmake/Hunter") + set(hunter_self "${root}") + else() + set( + hunter_self + "${root}/_Base/Download/Hunter/${version}/${archive_id}/Unpacked" + ) + endif() + + set("${result}" "${hunter_self}" PARENT_SCOPE) +endfunction() + +# Set HUNTER_GATE_ROOT cmake variable to suitable value. +function(hunter_gate_detect_root) + # Check CMake variable + string(COMPARE NOTEQUAL "${HUNTER_ROOT}" "" not_empty) + if(not_empty) + set(HUNTER_GATE_ROOT "${HUNTER_ROOT}" PARENT_SCOPE) + hunter_gate_status_debug("HUNTER_ROOT detected by cmake variable") + return() + endif() + + # Check environment variable + string(COMPARE NOTEQUAL "$ENV{HUNTER_ROOT}" "" not_empty) + if(not_empty) + set(HUNTER_GATE_ROOT "$ENV{HUNTER_ROOT}" PARENT_SCOPE) + hunter_gate_status_debug("HUNTER_ROOT detected by environment variable") + return() + endif() + + # Check HOME environment variable + string(COMPARE NOTEQUAL "$ENV{HOME}" "" result) + if(result) + set(HUNTER_GATE_ROOT "$ENV{HOME}/.hunter" PARENT_SCOPE) + hunter_gate_status_debug("HUNTER_ROOT set using HOME environment variable") + return() + endif() + + # Check SYSTEMDRIVE and USERPROFILE environment variable (windows only) + if(WIN32) + string(COMPARE NOTEQUAL "$ENV{SYSTEMDRIVE}" "" result) + if(result) + set(HUNTER_GATE_ROOT "$ENV{SYSTEMDRIVE}/.hunter" PARENT_SCOPE) + hunter_gate_status_debug( + "HUNTER_ROOT set using SYSTEMDRIVE environment variable" + ) + return() + endif() + + string(COMPARE NOTEQUAL "$ENV{USERPROFILE}" "" result) + if(result) + set(HUNTER_GATE_ROOT "$ENV{USERPROFILE}/.hunter" PARENT_SCOPE) + hunter_gate_status_debug( + "HUNTER_ROOT set using USERPROFILE environment variable" + ) + return() + endif() + endif() + + hunter_gate_fatal_error( + "Can't detect HUNTER_ROOT" + WIKI "error.detect.hunter.root" + ) +endfunction() + +macro(hunter_gate_lock dir) + if(NOT HUNTER_SKIP_LOCK) + if("${CMAKE_VERSION}" VERSION_LESS "3.2") + hunter_gate_fatal_error( + "Can't lock, upgrade to CMake 3.2 or use HUNTER_SKIP_LOCK" + WIKI "error.can.not.lock" + ) + endif() + hunter_gate_status_debug("Locking directory: ${dir}") + file(LOCK "${dir}" DIRECTORY GUARD FUNCTION) + hunter_gate_status_debug("Lock done") + endif() +endmacro() + +function(hunter_gate_download dir) + string( + COMPARE + NOTEQUAL + "$ENV{HUNTER_DISABLE_AUTOINSTALL}" + "" + disable_autoinstall + ) + if(disable_autoinstall AND NOT HUNTER_RUN_INSTALL) + hunter_gate_fatal_error( + "Hunter not found in '${dir}'" + "Set HUNTER_RUN_INSTALL=ON to auto-install it from '${HUNTER_GATE_URL}'" + "Settings:" + " HUNTER_ROOT: ${HUNTER_GATE_ROOT}" + " HUNTER_SHA1: ${HUNTER_GATE_SHA1}" + WIKI "error.run.install" + ) + endif() + string(COMPARE EQUAL "${dir}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("Empty 'dir' argument") + endif() + + string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("HUNTER_GATE_SHA1 empty") + endif() + + string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" is_bad) + if(is_bad) + hunter_gate_internal_error("HUNTER_GATE_URL empty") + endif() + + set(done_location "${dir}/DONE") + set(sha1_location "${dir}/SHA1") + + set(build_dir "${dir}/Build") + set(cmakelists "${dir}/CMakeLists.txt") + + hunter_gate_lock("${dir}") + if(EXISTS "${done_location}") + # while waiting for lock other instance can do all the job + hunter_gate_status_debug("File '${done_location}' found, skip install") + return() + endif() + + file(REMOVE_RECURSE "${build_dir}") + file(REMOVE_RECURSE "${cmakelists}") + + file(MAKE_DIRECTORY "${build_dir}") # check directory permissions + + # Disabling languages speeds up a little bit, reduces noise in the output + # and avoids path too long windows error + file( + WRITE + "${cmakelists}" + "cmake_minimum_required(VERSION 3.0)\n" + "project(HunterDownload LANGUAGES NONE)\n" + "include(ExternalProject)\n" + "ExternalProject_Add(\n" + " Hunter\n" + " URL\n" + " \"${HUNTER_GATE_URL}\"\n" + " URL_HASH\n" + " SHA1=${HUNTER_GATE_SHA1}\n" + " DOWNLOAD_DIR\n" + " \"${dir}\"\n" + " TLS_VERIFY\n" + " ${HUNTER_TLS_VERIFY}\n" + " SOURCE_DIR\n" + " \"${dir}/Unpacked\"\n" + " CONFIGURE_COMMAND\n" + " \"\"\n" + " BUILD_COMMAND\n" + " \"\"\n" + " INSTALL_COMMAND\n" + " \"\"\n" + ")\n" + ) + + if(HUNTER_STATUS_DEBUG) + set(logging_params "") + else() + set(logging_params OUTPUT_QUIET) + endif() + + hunter_gate_status_debug("Run generate") + + # Need to add toolchain file too. + # Otherwise on Visual Studio + MDD this will fail with error: + # "Could not find an appropriate version of the Windows 10 SDK installed on this machine" + if(EXISTS "${CMAKE_TOOLCHAIN_FILE}") + get_filename_component(absolute_CMAKE_TOOLCHAIN_FILE "${CMAKE_TOOLCHAIN_FILE}" ABSOLUTE) + set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=${absolute_CMAKE_TOOLCHAIN_FILE}") + else() + # 'toolchain_arg' can't be empty + set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=") + endif() + + string(COMPARE EQUAL "${CMAKE_MAKE_PROGRAM}" "" no_make) + if(no_make) + set(make_arg "") + else() + # Test case: remove Ninja from PATH but set it via CMAKE_MAKE_PROGRAM + set(make_arg "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}") + endif() + + execute_process( + COMMAND + "${CMAKE_COMMAND}" + "-H${dir}" + "-B${build_dir}" + "-G${CMAKE_GENERATOR}" + "${toolchain_arg}" + ${make_arg} + WORKING_DIRECTORY "${dir}" + RESULT_VARIABLE download_result + ${logging_params} + ) + + if(NOT download_result EQUAL 0) + hunter_gate_internal_error("Configure project failed") + endif() + + hunter_gate_status_print( + "Initializing Hunter workspace (${HUNTER_GATE_SHA1})" + " ${HUNTER_GATE_URL}" + " -> ${dir}" + ) + execute_process( + COMMAND "${CMAKE_COMMAND}" --build "${build_dir}" + WORKING_DIRECTORY "${dir}" + RESULT_VARIABLE download_result + ${logging_params} + ) + + if(NOT download_result EQUAL 0) + hunter_gate_internal_error("Build project failed") + endif() + + file(REMOVE_RECURSE "${build_dir}") + file(REMOVE_RECURSE "${cmakelists}") + + file(WRITE "${sha1_location}" "${HUNTER_GATE_SHA1}") + file(WRITE "${done_location}" "DONE") + + hunter_gate_status_debug("Finished") +endfunction() + +# Must be a macro so master file 'cmake/Hunter' can +# apply all variables easily just by 'include' command +# (otherwise PARENT_SCOPE magic needed) +macro(HunterGate) + if(HUNTER_GATE_DONE) + # variable HUNTER_GATE_DONE set explicitly for external project + # (see `hunter_download`) + set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES) + endif() + + # First HunterGate command will init Hunter, others will be ignored + get_property(_hunter_gate_done GLOBAL PROPERTY HUNTER_GATE_DONE SET) + + if(NOT HUNTER_ENABLED) + # Empty function to avoid error "unknown function" + function(hunter_add_package) + endfunction() + + set( + _hunter_gate_disabled_mode_dir + "${CMAKE_CURRENT_LIST_DIR}/cmake/Hunter/disabled-mode" + ) + if(EXISTS "${_hunter_gate_disabled_mode_dir}") + hunter_gate_status_debug( + "Adding \"disabled-mode\" modules: ${_hunter_gate_disabled_mode_dir}" + ) + list(APPEND CMAKE_PREFIX_PATH "${_hunter_gate_disabled_mode_dir}") + endif() + elseif(_hunter_gate_done) + hunter_gate_status_debug("Secondary HunterGate (use old settings)") + hunter_gate_self( + "${HUNTER_CACHED_ROOT}" + "${HUNTER_VERSION}" + "${HUNTER_SHA1}" + _hunter_self + ) + include("${_hunter_self}/cmake/Hunter") + else() + set(HUNTER_GATE_LOCATION "${CMAKE_CURRENT_LIST_DIR}") + + string(COMPARE NOTEQUAL "${PROJECT_NAME}" "" _have_project_name) + if(_have_project_name) + hunter_gate_fatal_error( + "Please set HunterGate *before* 'project' command. " + "Detected project: ${PROJECT_NAME}" + WIKI "error.huntergate.before.project" + ) + endif() + + cmake_parse_arguments( + HUNTER_GATE "LOCAL" "URL;SHA1;GLOBAL;FILEPATH" "" ${ARGV} + ) + + string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" _empty_sha1) + string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" _empty_url) + string( + COMPARE + NOTEQUAL + "${HUNTER_GATE_UNPARSED_ARGUMENTS}" + "" + _have_unparsed + ) + string(COMPARE NOTEQUAL "${HUNTER_GATE_GLOBAL}" "" _have_global) + string(COMPARE NOTEQUAL "${HUNTER_GATE_FILEPATH}" "" _have_filepath) + + if(_have_unparsed) + hunter_gate_user_error( + "HunterGate unparsed arguments: ${HUNTER_GATE_UNPARSED_ARGUMENTS}" + ) + endif() + if(_empty_sha1) + hunter_gate_user_error("SHA1 suboption of HunterGate is mandatory") + endif() + if(_empty_url) + hunter_gate_user_error("URL suboption of HunterGate is mandatory") + endif() + if(_have_global) + if(HUNTER_GATE_LOCAL) + hunter_gate_user_error("Unexpected LOCAL (already has GLOBAL)") + endif() + if(_have_filepath) + hunter_gate_user_error("Unexpected FILEPATH (already has GLOBAL)") + endif() + endif() + if(HUNTER_GATE_LOCAL) + if(_have_global) + hunter_gate_user_error("Unexpected GLOBAL (already has LOCAL)") + endif() + if(_have_filepath) + hunter_gate_user_error("Unexpected FILEPATH (already has LOCAL)") + endif() + endif() + if(_have_filepath) + if(_have_global) + hunter_gate_user_error("Unexpected GLOBAL (already has FILEPATH)") + endif() + if(HUNTER_GATE_LOCAL) + hunter_gate_user_error("Unexpected LOCAL (already has FILEPATH)") + endif() + endif() + + hunter_gate_detect_root() # set HUNTER_GATE_ROOT + + # Beautify path, fix probable problems with windows path slashes + get_filename_component( + HUNTER_GATE_ROOT "${HUNTER_GATE_ROOT}" ABSOLUTE + ) + hunter_gate_status_debug("HUNTER_ROOT: ${HUNTER_GATE_ROOT}") + if(NOT HUNTER_ALLOW_SPACES_IN_PATH) + string(FIND "${HUNTER_GATE_ROOT}" " " _contain_spaces) + if(NOT _contain_spaces EQUAL -1) + hunter_gate_fatal_error( + "HUNTER_ROOT (${HUNTER_GATE_ROOT}) contains spaces." + "Set HUNTER_ALLOW_SPACES_IN_PATH=ON to skip this error" + "(Use at your own risk!)" + WIKI "error.spaces.in.hunter.root" + ) + endif() + endif() + + string( + REGEX + MATCH + "[0-9]+\\.[0-9]+\\.[0-9]+[-_a-z0-9]*" + HUNTER_GATE_VERSION + "${HUNTER_GATE_URL}" + ) + string(COMPARE EQUAL "${HUNTER_GATE_VERSION}" "" _is_empty) + if(_is_empty) + set(HUNTER_GATE_VERSION "unknown") + endif() + + hunter_gate_self( + "${HUNTER_GATE_ROOT}" + "${HUNTER_GATE_VERSION}" + "${HUNTER_GATE_SHA1}" + _hunter_self + ) + + set(_master_location "${_hunter_self}/cmake/Hunter") + if(EXISTS "${HUNTER_GATE_ROOT}/cmake/Hunter") + # Hunter downloaded manually (e.g. by 'git clone') + set(_unused "xxxxxxxxxx") + set(HUNTER_GATE_SHA1 "${_unused}") + set(HUNTER_GATE_VERSION "${_unused}") + else() + get_filename_component(_archive_id_location "${_hunter_self}/.." ABSOLUTE) + set(_done_location "${_archive_id_location}/DONE") + set(_sha1_location "${_archive_id_location}/SHA1") + + # Check Hunter already downloaded by HunterGate + if(NOT EXISTS "${_done_location}") + hunter_gate_download("${_archive_id_location}") + endif() + + if(NOT EXISTS "${_done_location}") + hunter_gate_internal_error("hunter_gate_download failed") + endif() + + if(NOT EXISTS "${_sha1_location}") + hunter_gate_internal_error("${_sha1_location} not found") + endif() + file(READ "${_sha1_location}" _sha1_value) + string(COMPARE EQUAL "${_sha1_value}" "${HUNTER_GATE_SHA1}" _is_equal) + if(NOT _is_equal) + hunter_gate_internal_error( + "Short SHA1 collision:" + " ${_sha1_value} (from ${_sha1_location})" + " ${HUNTER_GATE_SHA1} (HunterGate)" + ) + endif() + if(NOT EXISTS "${_master_location}") + hunter_gate_user_error( + "Master file not found:" + " ${_master_location}" + "try to update Hunter/HunterGate" + ) + endif() + endif() + include("${_master_location}") + set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES) + endif() +endmacro() diff --git a/src/jaegertracing/jaeger-client-cpp/cmake/toolchain.cmake b/src/jaegertracing/jaeger-client-cpp/cmake/toolchain.cmake new file mode 100644 index 000000000..ad7a02ffd --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/cmake/toolchain.cmake @@ -0,0 +1,5 @@ +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_EXTENSIONS OFF) +set(CMAKE_POSITION_INDEPENDENT_CODE ON) +set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
\ No newline at end of file diff --git a/src/jaegertracing/jaeger-client-cpp/codecov.yml b/src/jaegertracing/jaeger-client-cpp/codecov.yml new file mode 100644 index 000000000..f47db21f0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/codecov.yml @@ -0,0 +1,31 @@ +codecov: + notify: + require_ci_to_pass: yes + +coverage: + precision: 2 + round: down + range: "70...100" + + status: + project: yes + patch: yes + changes: no + +parsers: + gcov: + branch_detection: + conditional: yes + loop: yes + method: no + macro: no + +comment: + layout: "reach, diff, flags, files, footer" + behavior: default + require_changes: no + +ignore: + - "src/jaegertracing/thrift-gen" + - "**/*Test.cpp" + - "crossdock" diff --git a/src/jaegertracing/jaeger-client-cpp/crossdock/Dockerfile b/src/jaegertracing/jaeger-client-cpp/crossdock/Dockerfile new file mode 100644 index 000000000..bfca32db6 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/crossdock/Dockerfile @@ -0,0 +1,10 @@ +FROM gcc:7.2 + +ADD ./build/crossdock / + +ENV AGENT_HOST_PORT=jaeger-agent:5775 +ENV SAMPLING_SERVER_URL=http://test_driver:5778/sampling + +EXPOSE 8080-8082 + +CMD ["/crossdock"] diff --git a/src/jaegertracing/jaeger-client-cpp/crossdock/Server.cpp b/src/jaegertracing/jaeger-client-cpp/crossdock/Server.cpp new file mode 100644 index 000000000..5ba85b743 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/crossdock/Server.cpp @@ -0,0 +1,808 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "Server.h" + +#include <atomic> +#include <cstdlib> +#include <future> +#include <sstream> +#include <thread> + +#include <nlohmann/json.hpp> + +#include "jaegertracing/Tracer.h" +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/net/Socket.h" +#include "jaegertracing/net/http/Request.h" +#include "jaegertracing/net/http/Response.h" + +namespace jaegertracing { +namespace crossdock { +namespace thrift { + +#define JSON_FROM_FIELD(var, field) \ + { \ + json[#field] = var.field; \ + } + +#define FIELD_FROM_JSON(var, field) \ + { \ + var.__set_##field(json.at(#field)); \ + } + +void to_json(nlohmann::json& json, const Transport::type& transport) +{ + json = _Transport_VALUES_TO_NAMES.at(static_cast<int>(transport)); +} + +void from_json(const nlohmann::json& json, Transport::type& transport) +{ + const auto str = json.get<std::string>(); + if (str == "HTTP") { + transport = Transport::HTTP; + return; + } + if (str == "TCHANNEL") { + transport = Transport::TCHANNEL; + return; + } + if (str == "DUMMY") { + transport = Transport::DUMMY; + return; + } + std::ostringstream oss; + oss << "Invalid transport value " << str; + throw std::invalid_argument(oss.str()); +} + +void to_json(nlohmann::json& json, const Downstream& downstream) +{ + JSON_FROM_FIELD(downstream, serviceName); + JSON_FROM_FIELD(downstream, serverRole); + JSON_FROM_FIELD(downstream, host); + JSON_FROM_FIELD(downstream, port); + JSON_FROM_FIELD(downstream, transport); + if (downstream.downstream) { + json["downstream"] = *downstream.downstream; + } +} + +void from_json(const nlohmann::json& json, Downstream& downstream) +{ + FIELD_FROM_JSON(downstream, serviceName); + FIELD_FROM_JSON(downstream, serverRole); + FIELD_FROM_JSON(downstream, host); + FIELD_FROM_JSON(downstream, port); + downstream.__set_transport(json.at("transport").get<Transport::type>()); + auto itr = json.find("downstream"); + if (itr != std::end(json) && !itr->is_null()) { + downstream.__set_downstream( + std::make_shared<Downstream>(itr->get<Downstream>())); + } +} + +void to_json(nlohmann::json& json, const StartTraceRequest& request) +{ + JSON_FROM_FIELD(request, serverRole); + JSON_FROM_FIELD(request, sampled); + JSON_FROM_FIELD(request, baggage); + JSON_FROM_FIELD(request, downstream); +} + +void from_json(const nlohmann::json& json, StartTraceRequest& request) +{ + FIELD_FROM_JSON(request, serverRole); + FIELD_FROM_JSON(request, sampled); + FIELD_FROM_JSON(request, baggage); + FIELD_FROM_JSON(request, downstream); +} + +void to_json(nlohmann::json& json, const JoinTraceRequest& request) +{ + JSON_FROM_FIELD(request, serverRole); + if (request.__isset.downstream) { + json["downstream"] = request.downstream; + } +} + +void from_json(const nlohmann::json& json, JoinTraceRequest& request) +{ + FIELD_FROM_JSON(request, serverRole); + auto itr = json.find("downstream"); + if (itr != std::end(json) && !itr->is_null()) { + request.__set_downstream(itr->get<Downstream>()); + } +} + +void to_json(nlohmann::json& json, const ObservedSpan& observedSpan) +{ + JSON_FROM_FIELD(observedSpan, traceId); + JSON_FROM_FIELD(observedSpan, sampled); + JSON_FROM_FIELD(observedSpan, baggage); +} + +void from_json(const nlohmann::json& json, ObservedSpan& observedSpan) +{ + FIELD_FROM_JSON(observedSpan, traceId); + FIELD_FROM_JSON(observedSpan, sampled); + FIELD_FROM_JSON(observedSpan, baggage); +} + +void to_json(nlohmann::json& json, const TraceResponse& response) +{ + if (response.__isset.span) { + JSON_FROM_FIELD(response, span); + } + if (response.downstream) { + json["downstream"] = *response.downstream; + } + JSON_FROM_FIELD(response, notImplementedError); +} + +void from_json(const nlohmann::json& json, TraceResponse& response) +{ + auto itr = json.find("span"); + if (itr != std::end(json) && !itr->is_null()) { + response.__set_span(itr->get<ObservedSpan>()); + } + itr = json.find("downstream"); + if (itr != std::end(json) && !itr->is_null()) { + response.__set_downstream( + std::make_shared<TraceResponse>(itr->get<TraceResponse>())); + } + FIELD_FROM_JSON(response, notImplementedError); +} + +#undef FIELD_FROM_JSON +#undef JSON_FROM_FIELD + +} // namespace thrift + +namespace { + +constexpr auto kBaggageKey = "crossdock-baggage-key"; +constexpr auto kDefaultTracerServiceName = "crossdock-cpp"; + +std::string escape(const std::string& str) +{ + std::string result; + result.reserve(str.size()); + for (auto&& ch : str) { + switch (ch) { + case '\n': { + result += "\\n"; + } break; + case '\r': { + result += "\\r"; + } break; + default: { + result += ch; + } break; + } + } + return result; +} + +std::string bufferedRead(net::Socket& socket) +{ + constexpr auto kBufferSize = 256; + std::array<char, kBufferSize> buffer; + std::string data; + auto numRead = ::read(socket.handle(), &buffer[0], buffer.size()); + data.append(&buffer[0], numRead); + while (numRead == kBufferSize) { + numRead = ::read(socket.handle(), &buffer[0], buffer.size()); + data.append(&buffer[0], numRead); + } + return data; +} + +class RequestReader : public opentracing::HTTPHeadersReader { + public: + explicit RequestReader(const net::http::Request& request) + : _request(request) + { + } + + opentracing::expected<void> ForeachKey( + std::function<opentracing::expected<void>(opentracing::string_view, + opentracing::string_view)> f) + const override + { + for (auto&& header : _request.headers()) { + const auto result = f(header.key(), header.value()); + if (!result) { + return result; + } + } + return opentracing::make_expected(); + } + + private: + const net::http::Request& _request; +}; + +class RequestWriter : public opentracing::HTTPHeadersWriter { + public: + explicit RequestWriter(std::ostream& requestStream) + : _requestStream(requestStream) + { + } + + opentracing::expected<void> + Set(opentracing::string_view key, + opentracing::string_view value) const override + { + _requestStream << key << ": " << value << "\r\n"; + return opentracing::make_expected(); + } + + private: + std::ostream& _requestStream; +}; + +thrift::ObservedSpan observeSpan(const opentracing::SpanContext& ctx) +{ + const auto& sc = static_cast<const SpanContext&>(ctx); + thrift::ObservedSpan observedSpan; + std::ostringstream oss; + oss << sc.traceID(); + observedSpan.__set_traceId(oss.str()); + observedSpan.__set_sampled(sc.isSampled()); + auto itr = sc.baggage().find(kBaggageKey); + if (itr != std::end(sc.baggage())) { + observedSpan.__set_baggage(itr->second); + } + return observedSpan; +} + +thrift::TraceResponse callDownstreamHTTP(const opentracing::SpanContext& ctx, + const thrift::Downstream& target, + opentracing::Tracer& tracer, + logging::Logger& logger) +{ + thrift::JoinTraceRequest request; + request.__set_serverRole(target.serverRole); + if (target.downstream) { + request.__set_downstream(*target.downstream); + } + + const auto requestJSON = nlohmann::json(request).dump(); + net::Socket socket; + socket.open(AF_INET, SOCK_STREAM); + const auto authority = target.host + ':' + target.port; + socket.connect("http://" + authority); + std::ostringstream oss; + oss << "POST /join_trace HTTP/1.1\r\n" + "Host: " + << authority << "\r\n"; + RequestWriter writer(oss); + tracer.Inject(ctx, writer); + oss << "Connection: close\r\n" + "Content-Type: application/json\r\n" + "Content-Length: " + << requestJSON.size() << "\r\n\r\n" + << requestJSON; + const auto message = oss.str(); + logger.info("Sending request downstream: " + escape(message)); + const auto numWritten = + ::write(socket.handle(), &message[0], message.size()); + (void)numWritten; + + const auto responseStr = bufferedRead(socket); + logger.info("Received downstream response: " + escape(responseStr)); + std::istringstream iss(responseStr); + auto response = net::http::Response::parse(iss); + return nlohmann::json::parse(response.body()); +} + +thrift::TraceResponse callDownstream(const opentracing::SpanContext& ctx, + const std::string& /* role */, + const thrift::Downstream& downstream, + opentracing::Tracer& tracer, + logging::Logger& logger) +{ + thrift::TraceResponse response; + + switch (downstream.transport) { + case thrift::Transport::HTTP: { + response = callDownstreamHTTP(ctx, downstream, tracer, logger); + } break; + case thrift::Transport::TCHANNEL: { + response.__set_notImplementedError( + "TCHANNEL transport not implemented"); + } break; + case thrift::Transport::DUMMY: { + response.__set_notImplementedError("DUMMY transport not implemented"); + } break; + default: { + throw std::invalid_argument("Unrecognized protocol " + + std::to_string(downstream.transport)); + } break; + } + + return response; +} + +thrift::TraceResponse prepareResponse(const opentracing::SpanContext& ctx, + const std::string& role, + const thrift::Downstream* downstream, + opentracing::Tracer& tracer, + logging::Logger& logger) +{ + const auto observedSpan = observeSpan(ctx); + thrift::TraceResponse response; + response.__set_span(observedSpan); + if (downstream) { + response.__set_downstream(std::make_shared<thrift::TraceResponse>( + callDownstream(ctx, role, *downstream, tracer, logger))); + } + return response; +} + +struct GenerateTracesRequest { + using StrMap = std::unordered_map<std::string, std::string>; + + std::string _type; + std::string _operation; + StrMap _tags; + int _count; +}; + +void from_json(const nlohmann::json& json, GenerateTracesRequest& request) +{ + request._type = json.at("type"); + request._operation = json.at("operation"); + request._tags = json.at("tags").get<GenerateTracesRequest::StrMap>(); + request._count = json.at("count"); +} + +} // anonymous namespace + +using Handler = std::function<std::string(const net::http::Request&)>; + +class Server::SocketListener { + public: + SocketListener(const net::IPAddress& ip, + const std::shared_ptr<logging::Logger>& logger, + Handler handler) + : _ip(ip) + , _logger(logger) + , _handler(handler) + , _running(false) + { + assert(_logger); + } + + ~SocketListener() { stop(); } + + void start() + { + std::promise<void> started; + _thread = std::thread([this, &started]() { start(_ip, started); }); + started.get_future().get(); + } + + void stop() noexcept + { + if (_running) { + _running = false; + _thread.join(); + _socket.close(); + } + } + + private: + void start(const net::IPAddress& ip, std::promise<void>& started) + { + _socket.open(AF_INET, SOCK_STREAM); + const auto enable = 1; + ::setsockopt(_socket.handle(), + SOL_SOCKET, + SO_REUSEADDR, + &enable, + sizeof(enable)); + _socket.bind(ip); + _socket.listen(); + _running = true; + started.set_value(); + + using TaskList = std::deque<std::future<void>>; + TaskList tasks; + + while (_running) { + auto client = _socket.accept(); + auto future = std::async( + std::launch::async, + [this](net::Socket&& socket) { + net::Socket client(std::move(socket)); + auto requestStr = bufferedRead(client); + _logger->info("Received request: " + escape(requestStr)); + + try { + std::istringstream iss(requestStr); + const auto request = net::http::Request::parse(iss); + const auto responseStr = _handler(request); + const auto numWritten = ::write(client.handle(), + &responseStr[0], + responseStr.size()); + if (numWritten != + static_cast<int>(responseStr.size())) { + std::ostringstream oss; + oss << "Unable to write entire response" + ", numWritten=" + << numWritten + << ", responseSize=" << responseStr.size(); + _logger->error(oss.str()); + } + } catch (...) { + utils::ErrorUtil::logError(*_logger, "Server error"); + constexpr auto message = + "HTTP/1.1 500 Internal Server Error\r\n\r\n"; + constexpr auto messageSize = sizeof(message) - 1; + const auto numWritten = + ::write(client.handle(), message, messageSize); + (void)numWritten; + } + + client.close(); + }, + std::move(client)); + tasks.emplace_back(std::move(future)); + } + + std::for_each(std::begin(tasks), + std::end(tasks), + [](TaskList::value_type& future) { future.get(); }); + } + + net::IPAddress _ip; + net::Socket _socket; + std::shared_ptr<logging::Logger> _logger; + Handler _handler; + std::atomic<bool> _running; + std::thread _thread; +}; + +class Server::EndToEndHandler { + public: + using TracerPtr = std::shared_ptr<opentracing::Tracer>; + + EndToEndHandler(const std::string& agentHostPort, + const std::string& collectorEndpoint, + const std::string& samplingServerURL) + : _agentHostPort(agentHostPort) + , _collectorEndpoint(collectorEndpoint) + , _samplingServerURL(samplingServerURL) + { + } + + TracerPtr findOrMakeTracer(std::string samplerType) + { + if (samplerType.empty()) { + samplerType = kSamplerTypeRemote; + } + + std::lock_guard<std::mutex> lock(_mutex); + auto itr = _tracers.find(samplerType); + if (itr != std::end(_tracers)) { + return itr->second; + } + return init(samplerType); + } + + private: + Config makeEndToEndConfig(const std::string& samplerType) const + { + return Config(false, + samplers::Config(samplerType, + 1.0, + _samplingServerURL, + samplers::Config::kDefaultMaxOperations, + std::chrono::seconds(5)), + reporters::Config(reporters::Config::kDefaultQueueSize, + std::chrono::seconds(1), + false, + _agentHostPort, + _collectorEndpoint)); + } + + TracerPtr init(const std::string& samplerType) + { + const auto config = makeEndToEndConfig(samplerType); + auto tracer = Tracer::make(kDefaultTracerServiceName, config); + _tracers[config.sampler().type()] = tracer; + return tracer; + } + + std::string _agentHostPort; + std::string _collectorEndpoint; + std::string _samplingServerURL; + std::unordered_map<std::string, TracerPtr> _tracers; + std::mutex _mutex; +}; + +Server::Server(const net::IPAddress& clientIP, + const net::IPAddress& serverIP, + const std::string& agentHostPort, + const std::string& collectorEndpoint, + const std::string& samplingServerURL) + : _logger(logging::consoleLogger()) + , _tracer(Tracer::make(kDefaultTracerServiceName, Config(), _logger)) + , _clientListener( + new SocketListener(clientIP, + _logger, + [this](const net::http::Request& request) { + return handleRequest(request); + })) + , _serverListener( + new SocketListener(serverIP, + _logger, + [this](const net::http::Request& request) { + return handleRequest(request); + })) + , _handler(new EndToEndHandler(agentHostPort, collectorEndpoint, samplingServerURL)) +{ +} + +Server::~Server() = default; + +void Server::serve() +{ + _clientListener->start(); + _serverListener->start(); +} + +template <typename RequestType> +std::string Server::handleJSON( + const net::http::Request& request, + std::function<thrift::TraceResponse( + const RequestType&, const opentracing::SpanContext&)> handler) +{ + RequestReader reader(request); + auto result = _tracer->Extract(reader); + if (!result) { + std::ostringstream oss; + oss << "Cannot read request body: opentracing error code " + << result.error().value(); + const auto message = oss.str(); + oss.str(""); + oss.clear(); + oss << "HTTP/1.1 400 Bad Request\r\n" + "Content-Length: " + << message.size() << "\r\n\r\n" + << message; + } + + std::unique_ptr<opentracing::SpanContext> ctx(result->release()); + opentracing::StartSpanOptions options; + options.start_system_timestamp = std::chrono::system_clock::now(); + options.start_steady_timestamp = std::chrono::steady_clock::now(); + if (ctx) { + options.references.emplace_back(std::make_pair( + opentracing::SpanReferenceType::ChildOfRef, ctx.get())); + } + auto span = _tracer->StartSpanWithOptions("post", options); + + RequestType thriftRequest; + try { + thriftRequest = nlohmann::json::parse(request.body()); + } catch (const std::exception& ex) { + std::ostringstream oss; + oss << "Cannot parse request JSON: " << ex.what() + << ", json: " << request.body(); + const auto message = oss.str(); + oss.str(""); + oss.clear(); + oss << "HTTP/1.1 500 Internal Server Error\r\n" + "Content-Length: " + << message.size() << "\r\n\r\n" + << message; + return oss.str(); + } catch (...) { + std::ostringstream oss; + oss << "Cannot parse request JSON, json: " << request.body(); + const auto message = oss.str(); + oss.str(""); + oss.clear(); + oss << "HTTP/1.1 500 Internal Server Error\r\n" + "Content-Length: " + << message.size() << "\r\n\r\n" + << message; + return oss.str(); + } + + const auto thriftResponse = handler(thriftRequest, span->context()); + try { + const auto message = nlohmann::json(thriftResponse).dump(); + std::ostringstream oss; + oss << "HTTP/1.1 200 OK\r\n" + "Content-Type: application/json\r\n" + "Content-Length: " + << message.size() << "\r\n\r\n" + << message; + return oss.str(); + } catch (const std::exception& ex) { + std::ostringstream oss; + oss << "Cannot marshal response to JSON: " << ex.what(); + const auto message = oss.str(); + oss.str(""); + oss.clear(); + oss << "HTTP/1.1 500 Internal Server Error\r\n" + "Content-Length: " + << message.size() << "\r\n\r\n" + << message; + return oss.str(); + } catch (...) { + std::ostringstream oss; + oss << "Cannot marshal response to JSON"; + const auto message = oss.str(); + oss.str(""); + oss.clear(); + oss << "HTTP/1.1 500 Internal Server Error\r\n" + "Content-Length: " + << message.size() << "\r\n\r\n" + << message; + return oss.str(); + } +} + +std::string Server::handleRequest(const net::http::Request& request) +{ + if (request.target() == "/") { + return "HTTP/1.1 200 OK\r\n\r\n"; + } + if (request.target() == "/start_trace") { + return handleJSON<thrift::StartTraceRequest>( + request, + [this](const thrift::StartTraceRequest& request, + const opentracing::SpanContext& /* ctx */) { + return startTrace(request); + }); + } + if (request.target() == "/join_trace") { + return handleJSON<thrift::JoinTraceRequest>( + request, + [this](const thrift::JoinTraceRequest& request, + const opentracing::SpanContext& ctx) { + return joinTrace(request, ctx); + }); + } + if (request.target() == "/create_traces") { + return generateTraces(request); + } + return "HTTP/1.1 404 Not Found\r\n\r\n"; +} + +thrift::TraceResponse +Server::startTrace(const crossdock::thrift::StartTraceRequest& request) +{ + auto span = _tracer->StartSpan(request.serverRole); + if (request.sampled) { + span->SetTag("sampling.priority", 1); + } + span->SetBaggageItem(kBaggageKey, request.baggage); + + return prepareResponse(span->context(), + request.serverRole, + &request.downstream, + *_tracer, + *_logger); +} + +thrift::TraceResponse +Server::joinTrace(const crossdock::thrift::JoinTraceRequest& request, + const opentracing::SpanContext& ctx) +{ + return prepareResponse(ctx, + request.serverRole, + request.__isset.downstream ? &request.downstream + : nullptr, + *_tracer, + *_logger); +} + +std::string Server::generateTraces(const net::http::Request& requestHTTP) +{ + GenerateTracesRequest request; + try { + request = nlohmann::json::parse(requestHTTP.body()); + } catch (const std::exception& ex) { + std::ostringstream oss; + oss << "JSON payload is invalid: " << ex.what(); + const auto message = oss.str(); + oss.str(""); + oss.clear(); + oss << "HTTP/1.1 400 Bad Request\r\n" + "Content-Length: " + << message.size() << "\r\n\r\n" + << message; + return oss.str(); + } catch (...) { + const std::string message("JSON payload is invalid"); + std::ostringstream oss; + oss << "HTTP/1.1 400 Bad Request\r\n" + "Content-Length: " + << message.size() << "\r\n\r\n" + << message; + return oss.str(); + } + + auto tracer = _handler->findOrMakeTracer(request._type); + if (!tracer) { + const std::string message("Tracer is not initialized"); + std::ostringstream oss; + oss << "HTTP/1.1 500 Internal Server Error\r\n" + "Content-Length: " + << message.size() << "\r\n" + << message; + return oss.str(); + } + + for (auto i = 0; i < request._count; ++i) { + auto span = tracer->StartSpan(request._operation); + for (auto&& pair : request._tags) { + span->SetTag(pair.first, pair.second); + } + span->Finish(); + } + + return "HTTP/1.1 200 OK\r\n\r\n"; +} + +} // namespace crossdock +} // namespace jaegertracing + +int main() +{ + const auto rawSenderType = std::getenv("SENDER"); + const std::string senderType(rawSenderType ? rawSenderType : ""); + + if (senderType.empty()) { + std::cerr << "env SENDER is not specified!\n"; + return 1; + } + + const auto rawAgentHostPort = std::getenv("AGENT_HOST_PORT"); + const std::string agentHostPort(rawAgentHostPort ? rawAgentHostPort : ""); + + if (agentHostPort.empty() && senderType == "udp") { + std::cerr << "env AGENT_HOST_PORT is not specified!\n"; + return 1; + } + + const std::string collectorEndpoint(senderType == "http" ? "http://jaeger-collector:14268/api/traces" : ""); + + const auto rawSamplingServerURL = std::getenv("SAMPLING_SERVER_URL"); + const std::string samplingServerURL( + rawSamplingServerURL ? rawSamplingServerURL : ""); + if (samplingServerURL.empty()) { + std::cerr << "env SAMPLING_SERVER_URL is not specified!\n"; + return 1; + } + + jaegertracing::crossdock::Server server( + jaegertracing::net::IPAddress::v4("0.0.0.0:8080"), + jaegertracing::net::IPAddress::v4("0.0.0.0:8081"), + agentHostPort, + collectorEndpoint, + samplingServerURL); + server.serve(); + + std::this_thread::sleep_for(std::chrono::hours(1)); + return 0; +} diff --git a/src/jaegertracing/jaeger-client-cpp/crossdock/Server.h b/src/jaegertracing/jaeger-client-cpp/crossdock/Server.h new file mode 100644 index 000000000..e02d32294 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/crossdock/Server.h @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_CROSSDOCK_SERVER_H +#define JAEGERTRACING_CROSSDOCK_SERVER_H + +#include <memory> + +#include <opentracing/tracer.h> + +#include "jaegertracing/thrift-gen/tracetest_types.h" + +namespace jaegertracing { +namespace logging { + +class Logger; + +} // namespace logging + +namespace net { + +class IPAddress; + +namespace http { + +class Request; + +} // namespace http +} // namespace net + +namespace crossdock { + +class Server { + public: + Server(const net::IPAddress& clientIP, + const net::IPAddress& serverIP, + const std::string& agentHostPort, + const std::string& collectorEndpoint, + const std::string& samplingServerURL); + + ~Server(); + + void serve(); + + private: + template <typename RequestType> + std::string handleJSON( + const net::http::Request& request, + std::function<thrift::TraceResponse( + const RequestType&, const opentracing::SpanContext&)> handler); + + std::string handleRequest(const net::http::Request& request); + + thrift::TraceResponse startTrace(const thrift::StartTraceRequest& request); + + thrift::TraceResponse joinTrace(const thrift::JoinTraceRequest& request, + const opentracing::SpanContext& ctx); + + std::string generateTraces(const net::http::Request& request); + + class SocketListener; + class EndToEndHandler; + + std::shared_ptr<logging::Logger> _logger; + std::shared_ptr<opentracing::Tracer> _tracer; + std::unique_ptr<SocketListener> _clientListener; + std::unique_ptr<SocketListener> _serverListener; + std::unique_ptr<EndToEndHandler> _handler; +}; + +} // namespace crossdock +} // namespace jaegertracing + +#endif // JAEGERTRACING_CROSSDOCK_SERVER_H diff --git a/src/jaegertracing/jaeger-client-cpp/crossdock/docker-compose.yml b/src/jaegertracing/jaeger-client-cpp/crossdock/docker-compose.yml new file mode 100644 index 000000000..550f0799f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/crossdock/docker-compose.yml @@ -0,0 +1,68 @@ +version: '2' + +services: + crossdock: + image: crossdock/crossdock + links: + - test_driver + - go + - cpp-udp + - cpp-http + environment: + - WAIT_FOR=test_driver,go,cpp-udp,cpp-http + - WAIT_FOR_TIMEOUT=60s + + - CALL_TIMEOUT=60s + + - AXIS_CLIENT=go + - AXIS_S1NAME=go,cpp-udp + - AXIS_SAMPLED=true,false + - AXIS_S2NAME=go,cpp-udp + - AXIS_S2TRANSPORT=http + - AXIS_S3NAME=go,cpp-udp + - AXIS_S3TRANSPORT=http + + - BEHAVIOR_TRACE=client,s1name,sampled,s2name,s2transport,s3name,s3transport + + - AXIS_TESTDRIVER=test_driver + - AXIS_SERVICES=cpp-udp,cpp-http + + - BEHAVIOR_ENDTOEND=testdriver,services + + - REPORT=compact + + go: + image: jaegertracing/xdock-go + ports: + - "8080-8082" + + cpp-udp: + depends_on: + - test_driver + build: + context: $PWD + dockerfile: crossdock/Dockerfile + ports: + - "8080-8082" + environment: + - SENDER=udp + + cpp-http: + depends_on: + - test_driver + build: + context: $PWD + dockerfile: crossdock/Dockerfile + ports: + - "8080-8082" + environment: + - SENDER=http + + test_driver: + image: jaegertracing/test-driver + depends_on: + - jaeger-query + - jaeger-collector + - jaeger-agent + ports: + - "8080" diff --git a/src/jaegertracing/jaeger-client-cpp/examples/App.cpp b/src/jaegertracing/jaeger-client-cpp/examples/App.cpp new file mode 100644 index 000000000..f7df8a2af --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/examples/App.cpp @@ -0,0 +1,45 @@ +#include <iostream> + +#include <yaml-cpp/yaml.h> + +#include <jaegertracing/Tracer.h> + +namespace { + +void setUpTracer(const char* configFilePath) +{ + auto configYAML = YAML::LoadFile(configFilePath); + auto config = jaegertracing::Config::parse(configYAML); + auto tracer = jaegertracing::Tracer::make( + "example-service", config, jaegertracing::logging::consoleLogger()); + opentracing::Tracer::InitGlobal( + std::static_pointer_cast<opentracing::Tracer>(tracer)); +} + +void tracedSubroutine(const std::unique_ptr<opentracing::Span>& parentSpan) +{ + auto span = opentracing::Tracer::Global()->StartSpan( + "tracedSubroutine", { opentracing::ChildOf(&parentSpan->context()) }); +} + +void tracedFunction() +{ + auto span = opentracing::Tracer::Global()->StartSpan("tracedFunction"); + tracedSubroutine(span); +} + +} // anonymous namespace + +int main(int argc, char* argv[]) +{ + if (argc < 2) { + std::cerr << "usage: " << argv[0] << " <config-yaml-path>\n"; + return 1; + } + setUpTracer(argv[1]); + tracedFunction(); + // Not stricly necessary to close tracer, but might flush any buffered + // spans. See more details in opentracing::Tracer::Close() documentation. + opentracing::Tracer::Global()->Close(); + return 0; +} diff --git a/src/jaegertracing/jaeger-client-cpp/examples/config.yml b/src/jaegertracing/jaeger-client-cpp/examples/config.yml new file mode 100644 index 000000000..340eb5110 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/examples/config.yml @@ -0,0 +1,6 @@ +disabled: false +reporter: + logSpans: true +sampler: + type: const + param: 1 diff --git a/src/jaegertracing/jaeger-client-cpp/idl/.gitignore b/src/jaegertracing/jaeger-client-cpp/idl/.gitignore new file mode 100644 index 000000000..5eaf37d73 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/.gitignore @@ -0,0 +1,6 @@ +.idea/ +gen-go/ +gen-java/ +gen-nodejs/ +gen-py.tornado/ +gen-cpp/ diff --git a/src/jaegertracing/jaeger-client-cpp/idl/.travis.yml b/src/jaegertracing/jaeger-client-cpp/idl/.travis.yml new file mode 100644 index 000000000..8418b117b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/.travis.yml @@ -0,0 +1,10 @@ +sudo: required + +services: + - docker + +before_install: + - docker version + +script: + - make test-ci diff --git a/src/jaegertracing/jaeger-client-cpp/idl/CONTRIBUTING.md b/src/jaegertracing/jaeger-client-cpp/idl/CONTRIBUTING.md new file mode 100644 index 000000000..088e5f7a8 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/CONTRIBUTING.md @@ -0,0 +1,117 @@ +# How to Contribute to Jaeger + +We'd love your help! + +Jaeger is [Apache 2.0 licensed](LICENSE) and accepts contributions via GitHub +pull requests. This document outlines some of the conventions on development +workflow, commit message formatting, contact points and other resources to make +it easier to get your contribution accepted. + +We gratefully welcome improvements to documentation as well as to code. + +# Certificate of Origin + +By contributing to this project you agree to the [Developer Certificate of +Origin](https://developercertificate.org/) (DCO). This document was created +by the Linux Kernel community and is a simple statement that you, as a +contributor, have the legal right to make the contribution. See the [DCO](DCO) +file for details. + +## Making A Change + +*Before making any significant changes, please [open an +issue](https://github.com/uber/jaeger/issues).* Discussing your proposed +changes ahead of time will make the contribution process smooth for everyone. + +Once we've discussed your changes and you've got your code ready, make sure +that tests are passing (`make test-ci`) and open your PR. Your +pull request is most likely to be accepted if: + +* It has a [good commit + message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html). +* Each commit must be signed by the author ([see below](#sign-your-work)). + +## License + +By contributing your code, you agree to license your contribution under the terms +of the [Apache License](LICENSE). + +If you are adding a new file it should have a header like below. + +``` +# Copyright (c) 2017 The Jaeger Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +``` + +## Sign your work + +The sign-off is a simple line at the end of the explanation for the +patch, which certifies that you wrote it or otherwise have the right to +pass it on as an open-source patch. The rules are pretty simple: if you +can certify the below (from +[developercertificate.org](http://developercertificate.org/)): + +``` +Developer Certificate of Origin +Version 1.1 + +Copyright (C) 2004, 2006 The Linux Foundation and its contributors. +660 York Street, Suite 102, +San Francisco, CA 94110 USA + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + + +Developer's Certificate of Origin 1.1 + +By making a contribution to this project, I certify that: + +(a) The contribution was created in whole or in part by me and I + have the right to submit it under the open source license + indicated in the file; or + +(b) The contribution is based upon previous work that, to the best + of my knowledge, is covered under an appropriate open source + license and I have the right under that license to submit that + work with modifications, whether created in whole or in part + by me, under the same open source license (unless I am + permitted to submit under a different license), as indicated + in the file; or + +(c) The contribution was provided directly to me by some other + person who certified (a), (b) or (c) and I have not modified + it. + +(d) I understand and agree that this project and the contribution + are public and that a record of the contribution (including all + personal information I submit with it, including my sign-off) is + maintained indefinitely and may be redistributed consistent with + this project or the open source license(s) involved. +``` + +then you just add a line to every git commit message: + + Signed-off-by: Joe Smith <joe@gmail.com> + +using your real name (sorry, no pseudonyms or anonymous contributions.) + +You can add the sign off when creating the git commit via `git commit -s`. + +If you want this to be automatic you can set up some aliases: + +``` +git config --add alias.amend "commit -s --amend" +git config --add alias.c "commit -s" +``` diff --git a/src/jaegertracing/jaeger-client-cpp/idl/DCO b/src/jaegertracing/jaeger-client-cpp/idl/DCO new file mode 100644 index 000000000..068953d4b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/DCO @@ -0,0 +1,37 @@ +Developer Certificate of Origin +Version 1.1 + +Copyright (C) 2004, 2006 The Linux Foundation and its contributors. +660 York Street, Suite 102, +San Francisco, CA 94110 USA + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + + +Developer's Certificate of Origin 1.1 + +By making a contribution to this project, I certify that: + +(a) The contribution was created in whole or in part by me and I + have the right to submit it under the open source license + indicated in the file; or + +(b) The contribution is based upon previous work that, to the best + of my knowledge, is covered under an appropriate open source + license and I have the right under that license to submit that + work with modifications, whether created in whole or in part + by me, under the same open source license (unless I am + permitted to submit under a different license), as indicated + in the file; or + +(c) The contribution was provided directly to me by some other + person who certified (a), (b) or (c) and I have not modified + it. + +(d) I understand and agree that this project and the contribution + are public and that a record of the contribution (including all + personal information I submit with it, including my sign-off) is + maintained indefinitely and may be redistributed consistent with + this project or the open source license(s) involved. + diff --git a/src/jaegertracing/jaeger-client-cpp/idl/LICENSE b/src/jaegertracing/jaeger-client-cpp/idl/LICENSE new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/src/jaegertracing/jaeger-client-cpp/idl/Makefile b/src/jaegertracing/jaeger-client-cpp/idl/Makefile new file mode 100644 index 000000000..f267cdcbf --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/Makefile @@ -0,0 +1,39 @@ + +THRIFT_VER=0.9.2 +THRIFT_IMG=thrift:$(THRIFT_VER) +THRIFT=docker run -u $(shell id -u) -v "${PWD}:/data" $(THRIFT_IMG) thrift + +SWAGGER_VER=0.12.0 +SWAGGER_IMAGE=quay.io/goswagger/swagger:$(SWAGGER_VER) +SWAGGER=docker run --rm -it -u ${shell id -u} -v "${PWD}:/go/src/${PROJECT_ROOT}" -w /go/src/${PROJECT_ROOT} $(SWAGGER_IMAGE) + +THRIFT_GO_ARGS=thrift_import="github.com/apache/thrift/lib/go/thrift" +THRIFT_PY_ARGS=new_style,tornado +THRIFT_JAVA_ARGS=private-members +THRIFT_PHP_ARGS=psr4 + +THRIFT_GEN=--gen go:$(THRIFT_GO_ARGS) --gen py:$(THRIFT_PY_ARGS) --gen java:$(THRIFT_JAVA_ARGS) --gen js:node --gen cpp --gen php:$(THRIFT_PHP_ARGS) +THRIFT_CMD=$(THRIFT) -o /data $(THRIFT_GEN) + +THRIFT_FILES=agent.thrift jaeger.thrift sampling.thrift zipkincore.thrift crossdock/tracetest.thrift \ + baggage.thrift dependency.thrift aggregation_validator.thrift + +test-ci: thrift swagger-validate + +swagger-validate: + $(SWAGGER) validate ./swagger/zipkin2-api.yaml + +clean: + rm -rf gen-* || true + +thrift: thrift-image clean $(THRIFT_FILES) + +$(THRIFT_FILES): + @echo Compiling $@ + $(THRIFT_CMD) /data/thrift/$@ + +thrift-image: + docker pull $(THRIFT_IMG) + $(THRIFT) -version + +.PHONY: test-ci clean thrift thrift-image $(THRIFT_FILES) swagger-validate diff --git a/src/jaegertracing/jaeger-client-cpp/idl/README.md b/src/jaegertracing/jaeger-client-cpp/idl/README.md new file mode 100644 index 000000000..05344439a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/README.md @@ -0,0 +1,15 @@ +# jaeger-idl [![Build Status][ci-img]][ci] + +A set of shared data model definitions used by Jaeger components. + +## Contributing + +See [CONTRIBUTING](./CONTRIBUTING.md). + +## License + +[Apache 2.0 License](./LICENSE). + + +[ci-img]: https://travis-ci.org/jaegertracing/jaeger-idl.svg?branch=master +[ci]: https://travis-ci.org/jaegertracing/jaeger-idl diff --git a/src/jaegertracing/jaeger-client-cpp/idl/swagger/zipkin2-api.yaml b/src/jaegertracing/jaeger-client-cpp/idl/swagger/zipkin2-api.yaml new file mode 100644 index 000000000..f97c3f15b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/swagger/zipkin2-api.yaml @@ -0,0 +1,415 @@ +swagger: "2.0" +info: + version: "1.0.0" + title: Zipkin API + description: | + Zipkin's v2 api currently includes a POST endpoint that can receive spans. +host: localhost:9411 +basePath: /api/v2 +schemes: + - http + - https +consumes: + - application/json +paths: + /services: + get: + description: | + Returns a list of all service names associated with span endpoints. + responses: + 200: + description: Succes + schema: + type: array + items: + type: string + 400: + description: Bad Request Error + /spans: + get: + description: Get all the span names recorded by a particular service + parameters: + - name: serviceName + in: query + required: true + description: | + Ex favstar (required) - Lower-case label of a node in the service + graph. The /services endpoint enumerates possible input values. + type: string + responses: + 200: + description: OK + schema: + type: array + items: + type: string + 400: + description: Bad Request Error + post: + description: | + Uploads a list of spans encoded per content-type, for example json. + consumes: + - application/json + produces: [] + parameters: + - name: spans + in: body + description: A list of spans that belong to any trace. + required: true + schema: + $ref: "#/definitions/ListOfSpans" + responses: + 202: + description: Accepted + /traces: + get: + description: | + Invoking this request retrieves traces matching the below filters. + + Results should be filtered against endTs, subject to limit and + lookback. For example, if endTs is 10:20 today, limit is 10, and + lookback is 7 days, traces returned should be those nearest to 10:20 + today, not 10:20 a week ago. + + Time units of endTs and lookback are milliseconds as opposed to + microseconds, the grain of Span.timestamp. Milliseconds is a more + familiar and supported granularity for query, index and windowing + functions + parameters: + - name: serviceName + in: query + required: false + description: | + Ex favstar (required) - Lower-case label of a node in the service + graph. The /services endpoint enumerates possible input values. + type: string + - name: spanName + in: query + required: false + description: | + Ex get - name of a span in a trace. + Only return traces that contains spans with this name. + type: string + - name: annotationQuery + in: query + type: string + required: false + description: | + Ex. `http.uri=/foo and retried` - If key/value (has an `=`), + constrains against Span.tags entres. If just a word, constrains + against Span.annotations[].value or Span.tags[].key. Any values are + AND against eachother. This means a span in the trace must match + all of these. + - name: minDuration + in: query + type: integer + description: | + Ex. 100000 (for 100ms). Only return traces whose `Span.duration` is + greater than or equal to minDuration microseconds. + - name: maxDuration + in: query + type: integer + description: | + Only return traces whose Span.duration is less than or equal to + `maxDuration` microseconds. Only valid with minDuration. + - name: endTs + in: query + type: integer + format: int64 + description: | + Only return traces where all Span.timestamp are at or before this + time in epoch milliseconds. Defaults to current time. + - name: lookback + type: integer + format: int64 + in: query + description: | + Only return traces where all Span.timestamp are at or after (endTs + - * lookback) in milliseconds. Defaults to endTs, limited to a + system parameter QUERY_LOOKBACK + - name: limit + in: query + default: 10 + type: integer + description: | + Maximum number of traces to return. Defaults to 10 + responses: + 200: + description: OK + schema: + $ref: "#/definitions/ListOfTraces" + /trace/{traceId}: + get: + parameters: + - name: traceId + in: path + required: true + type: string + maxLength: 32 + minLength: 16 + pattern: "[a-z0-9]{16,32}" + description: | + Trace identifier, set on all spans within it. + + Encoded as 16 or 32 lowercase hex characters corresponding to 64 or 128 bits. + For example, a 128bit trace ID looks like 4e441824ec2b6a44ffdc9bb9a6453df3 + responses: + 200: + description: OK + schema: + $ref: "#/definitions/Trace" + 404: + description: "`traceId` not found" + /dependencies: + get: + description: | + Returns service links derived from spans. + parameters: + - name: endTs + in: query + description: | + only return links from spans where `Span.timestamp` are at or before + this time in epoch milliseconds. + required: true + type: integer + format: int64 + - name: lookback + in: query + description: | + only return links where all Span.timestamp are at or after + (`endTs - * lookback`) in milliseconds. Defaults to `endTs`, limited + to a system parameter `QUERY_LOOKBACK` + type: integer + format: int64 + responses: + 200: + description: OK + schema: + type: array + title: ListOfDependencyLinks + items: + $ref: "#/definitions/DependencyLink" +definitions: + Endpoint: + type: object + title: Endpoint + description: The network context of a node in the service graph + properties: + serviceName: + type: string + description: | + Lower-case label of this node in the service graph, such as "favstar". Leave + absent if unknown. + + This is a primary label for trace lookup and aggregation, so it should be + intuitive and consistent. Many use a name from service discovery. + ipv4: + type: string + format: ipv4 + description: | + The text representation of the primary IPv4 address associated with this + a connection. Ex. 192.168.99.100 Absent if unknown. + ipv6: + type: string + format: ipv6 + description: | + The text representation of the primary IPv6 address associated with this + a connection. Ex. 2001:db8::c001 Absent if unknown. + + Prefer using the ipv4 field for mapped addresses. + port: + type: integer + description: | + Depending on context, this could be a listen port or the client-side of a + socket. Absent if unknown + Annotation: + title: Annotation + type: object + description: | + Associates an event that explains latency with a timestamp. + Unlike log statements, annotations are often codes. Ex. "ws" for WireSend + + Zipkin v1 core annotations such as "cs" and "sr" have been replaced with + Span.Kind, which interprets timestamp and duration. + properties: + timestamp: + type: integer + description: | + Epoch **microseconds** of this event. + + For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC + + This value should be set directly by instrumentation, using the most precise + value possible. For example, gettimeofday or multiplying epoch millis by 1000. + value: + type: string + description: | + Usually a short tag indicating an event, like "error" + + While possible to add larger data, such as garbage collection details, low + cardinality event names both keep the size of spans down and also are easy + to search against. + Tags: + type: object + title: Tags + description: | + Adds context to a span, for search, viewing and analysis. + + For example, a key "your_app.version" would let you lookup traces by version. + A tag "sql.query" isn't searchable, but it can help in debugging when viewing + a trace. + additionalProperties: + type: string + ListOfSpans: + title: ListOfSpans + description: 'A list of spans with possibly different trace ids, in no particular order' + type: array + items: + $ref: "#/definitions/Span" + Trace: + title: Trace + type: array + description: 'List of spans who have the same trace ID.' + items: + $ref: "#/definitions/Span" + ListOfTraces: + title: ListOfTraces + type: array + items: + $ref: "#/definitions/Trace" + Span: + title: Span + type: object + required: + - traceId + - id + properties: + traceId: + type: string + maxLength: 32 + minLength: 16 + pattern: "[a-z0-9]{16,32}" + description: | + Randomly generated, unique identifier for a trace, set on all spans within it. + + Encoded as 16 or 32 lowercase hex characters corresponding to 64 or 128 bits. + For example, a 128bit trace ID looks like 4e441824ec2b6a44ffdc9bb9a6453df3 + name: + type: string + description: | + The logical operation this span represents in lowercase (e.g. rpc method). + Leave absent if unknown. + + As these are lookup labels, take care to ensure names are low cardinality. + For example, do not embed variables into the name. + parentId: + type: string + pattern: "[a-z0-9]{16}" + maxLength: 16 + minLength: 16 + description: 'The parent span ID or absent if this the root span in a trace.' + id: + type: string + pattern: "[a-z0-9]{16}" + maxLength: 16 + minLength: 16 + description: | + Unique 64bit identifier for this operation within the trace. + + Encoded as 16 lowercase hex characters. For example ffdc9bb9a6453df3 + kind: + type: string + enum: + - CLIENT + - SERVER + - PRODUCER + - CONSUMER + description: | + When present, clarifies timestamp, duration and remoteEndpoint. When + absent, the span is local or incomplete. Unlike client and server, + there is no direct critical path latency relationship between producer + and consumer spans. + + * `CLIENT` + * timestamp - The moment a request was sent (formerly "cs") + * duration - When present indicates when a response was received (formerly "cr") + * remoteEndpoint - Represents the server. Leave serviceName absent if unknown. + * `SERVER` + * timestamp - The moment a request was received (formerly "sr") + * duration - When present indicates when a response was sent (formerly "ss") + * remoteEndpoint - Represents the client. Leave serviceName absent if unknown. + * `PRODUCER` + * timestamp - The moment a message was sent to a destination (formerly "ms") + * duration - When present represents delay sending the message, such as batching. + * remoteEndpoint - Represents the broker. Leave serviceName absent if unknown. + * `CONSUMER` + * timestamp - The moment a message was received from an origin (formerly "mr") + * duration - When present represents delay consuming the message, such as from backlog. + * remoteEndpoint - Represents the broker. Leave serviceName absent if unknown. + timestamp: + type: integer + format: int64 + description: | + Epoch **microseconds** of the start of this span, possibly absent if incomplete. + + For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC + + This value should be set directly by instrumentation, using the most precise + value possible. For example, gettimeofday or multiplying epoch millis by 1000. + + There are three known edge-cases where this could be reported absent. + * A span was allocated but never started (ex not yet received a timestamp) + * The span's start event was lost + * Data about a completed span (ex tags) were sent after the fact + duration: + type: integer + format: int64 + minimum: 1 + description: | + Duration in **microseconds** of the critical path, if known. Durations of less + than one are rounded up. Duration of children can be longer than their parents + due to asynchronous operations. + + For example 150 milliseconds is 150000 microseconds. + debug: + type: boolean + description: | + True is a request to store this span even if it overrides sampling policy. + + This is true when the `X-B3-Flags` header has a value of 1. + shared: + type: boolean + description: 'True if we are contributing to a span started by another tracer (ex on a different host).' + localEndpoint: + $ref: "#/definitions/Endpoint" + description: | + The host that recorded this span, primarily for query by service name. + + Instrumentation should always record this. Usually, absent implies late data. + The IP address corresponding to this is usually the site local or advertised + service address. When present, the port indicates the listen port. + remoteEndpoint: + $ref: "#/definitions/Endpoint" + description: | + When an RPC (or messaging) span, indicates the other side of the connection. + annotations: + type: array + uniqueItems: true + items: + $ref: '#/definitions/Annotation' + description: 'Associates events that explain latency with the time they happened.' + tags: + $ref: '#/definitions/Tags' + description: 'Tags give your span context for search, viewing and analysis.' + DependencyLink: + title: DependencyLink + type: object + properties: + parent: + type: string + child: + type: string + callCount: + type: integer + errorCount: + type: integer
\ No newline at end of file diff --git a/src/jaegertracing/jaeger-client-cpp/idl/thrift/agent.thrift b/src/jaegertracing/jaeger-client-cpp/idl/thrift/agent.thrift new file mode 100644 index 000000000..b7c152bda --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/thrift/agent.thrift @@ -0,0 +1,26 @@ +# Copyright (c) 2016 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +include "jaeger.thrift" +include "zipkincore.thrift" + +namespace cpp jaegertracing.agent.thrift +namespace java io.jaegertracing.agent.thrift +namespace php Jaeger.Thrift.Agent +namespace netcore Jaeger.Thrift.Agent + +service Agent { + oneway void emitZipkinBatch(1: list<zipkincore.Span> spans) + oneway void emitBatch(1: jaeger.Batch batch) +} diff --git a/src/jaegertracing/jaeger-client-cpp/idl/thrift/aggregation_validator.thrift b/src/jaegertracing/jaeger-client-cpp/idl/thrift/aggregation_validator.thrift new file mode 100644 index 000000000..733d97432 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/thrift/aggregation_validator.thrift @@ -0,0 +1,28 @@ +# Copyright (c) 2017 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +namespace cpp jaegertracing.thrift +namespace java io.jaegertracing.thriftjava +namespace php Jaeger.Thrift.Agent +namespace netcore Jaeger.Thrift.Agent + +# ValidateTraceResponse returns ok when a trace has been written to redis. +struct ValidateTraceResponse { + 1: required bool ok + 2: required i64 traceCount +} + +service AggregationValidator { + ValidateTraceResponse validateTrace(1: required string traceId) +} diff --git a/src/jaegertracing/jaeger-client-cpp/idl/thrift/baggage.thrift b/src/jaegertracing/jaeger-client-cpp/idl/thrift/baggage.thrift new file mode 100644 index 000000000..56a27a128 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/thrift/baggage.thrift @@ -0,0 +1,33 @@ +# Copyright (c) 2017 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +namespace cpp jaegertracing.thrift +namespace java io.jaegertracing.thriftjava +namespace php Jaeger.Thrift.Agent +namespace netcore Jaeger.Thrift.Agent + +# BaggageRestriction contains the baggage key and the maximum length of the baggage value. +struct BaggageRestriction { + 1: required string baggageKey + 2: required i32 maxValueLength +} + +service BaggageRestrictionManager { + /** + * getBaggageRestrictions retrieves the baggage restrictions for a specific service. + * Usually, baggageRestrictions apply to all services however there may be situations + * where a baggageKey might only be allowed to be set by a specific service. + */ + list<BaggageRestriction> getBaggageRestrictions(1: string serviceName) +} diff --git a/src/jaegertracing/jaeger-client-cpp/idl/thrift/crossdock/tracetest.thrift b/src/jaegertracing/jaeger-client-cpp/idl/thrift/crossdock/tracetest.thrift new file mode 100644 index 000000000..d923b1029 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/thrift/crossdock/tracetest.thrift @@ -0,0 +1,64 @@ +# Copyright (c) 2016 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +namespace cpp jaegertracing.crossdock.thrift +namespace java io.jaegertracing.crossdock.thrift +namespace php Jaeger.Thrift.Crossdock +namespace netcore Jaeger.Thrift.Crossdock + +enum Transport { HTTP, TCHANNEL, DUMMY } + +struct Downstream { + 1: required string serviceName + 2: required string serverRole + 3: required string host + 4: required string port + 5: required Transport transport + 6: optional Downstream downstream +} + +struct StartTraceRequest { + 1: required string serverRole // role of the server (always S1) + 2: required bool sampled + 3: required string baggage + 4: required Downstream downstream +} + +struct JoinTraceRequest { + 1: required string serverRole // role of the server, S2 or S3 + 2: optional Downstream downstream +} + +struct ObservedSpan { + 1: required string traceId + 2: required bool sampled + 3: required string baggage +} + +/** + * Each server must include the information about the span it observed. + * It can only be omitted from the response if notImplementedError field is not empty. + * If the server was instructed to make a downstream call, it must embed the + * downstream response in its own response. + */ +struct TraceResponse { + 1: optional ObservedSpan span + 2: optional TraceResponse downstream + 3: required string notImplementedError +} + +service TracedService { + TraceResponse startTrace(1: StartTraceRequest request) + TraceResponse joinTrace(1: JoinTraceRequest request) +} diff --git a/src/jaegertracing/jaeger-client-cpp/idl/thrift/dependency.thrift b/src/jaegertracing/jaeger-client-cpp/idl/thrift/dependency.thrift new file mode 100644 index 000000000..781e1c4a5 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/thrift/dependency.thrift @@ -0,0 +1,37 @@ +# Copyright (c) 2017 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +namespace cpp jaegertracing.thrift +namespace java io.jaegertracing.thriftjava +namespace php Jaeger.Thrift.Agent +namespace netcore Jaeger.Thrift.Agent + +struct DependencyLink { + // parent service name (caller) + 1: required string parent + // child service name (callee) + 2: required string child + // calls made during the duration of this link + 4: required i64 callCount +} + +// An aggregate representation of services paired with every service they call. +struct Dependencies { + 1: required list<DependencyLink> links +} + +service Dependency { + Dependencies getDependenciesForTrace(1: required string traceId) + oneway void saveDependencies(1: Dependencies dependencies) +} diff --git a/src/jaegertracing/jaeger-client-cpp/idl/thrift/jaeger.thrift b/src/jaegertracing/jaeger-client-cpp/idl/thrift/jaeger.thrift new file mode 100644 index 000000000..96cc751d9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/thrift/jaeger.thrift @@ -0,0 +1,84 @@ +# Copyright (c) 2016 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +namespace cpp jaegertracing.thrift +namespace java io.jaegertracing.thriftjava +namespace php Jaeger.Thrift +namespace netcore Jaeger.Thrift + +# TagType denotes the type of a Tag's value. +enum TagType { STRING, DOUBLE, BOOL, LONG, BINARY } + +# Tag is a basic strongly typed key/value pair. It has been flattened to reduce the use of pointers in golang +struct Tag { + 1: required string key + 2: required TagType vType + 3: optional string vStr + 4: optional double vDouble + 5: optional bool vBool + 6: optional i64 vLong + 7: optional binary vBinary +} + +# Log is a timed even with an arbitrary set of tags. +struct Log { + 1: required i64 timestamp + 2: required list<Tag> fields +} + +enum SpanRefType { CHILD_OF, FOLLOWS_FROM } + +# SpanRef describes causal relationship of the current span to another span (e.g. 'child-of') +struct SpanRef { + 1: required SpanRefType refType + 2: required i64 traceIdLow + 3: required i64 traceIdHigh + 4: required i64 spanId +} + +# Span represents a named unit of work performed by a service. +struct Span { + 1: required i64 traceIdLow # the least significant 64 bits of a traceID + 2: required i64 traceIdHigh # the most significant 64 bits of a traceID; 0 when only 64bit IDs are used + 3: required i64 spanId # unique span id (only unique within a given trace) + 4: required i64 parentSpanId # since nearly all spans will have parents spans, CHILD_OF refs do not have to be explicit + 5: required string operationName + 6: optional list<SpanRef> references # causal references to other spans + 7: required i32 flags # a bit field used to propagate sampling decisions. 1 signifies a SAMPLED span, 2 signifies a DEBUG span. + 8: required i64 startTime + 9: required i64 duration + 10: optional list<Tag> tags + 11: optional list<Log> logs +} + +# Process describes the traced process/service that emits spans. +struct Process { + 1: required string serviceName + 2: optional list<Tag> tags +} + +# Batch is a collection of spans reported out of process. +struct Batch { + 1: required Process process + 2: required list<Span> spans +} + +# BatchSubmitResponse is the response on submitting a batch. +struct BatchSubmitResponse { + 1: required bool ok # The Collector's client is expected to only log (or emit a counter) when not ok equals false +} + +service Collector { + list<BatchSubmitResponse> submitBatches(1: list<Batch> batches) +} diff --git a/src/jaegertracing/jaeger-client-cpp/idl/thrift/sampling.thrift b/src/jaegertracing/jaeger-client-cpp/idl/thrift/sampling.thrift new file mode 100644 index 000000000..7215eaa71 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/thrift/sampling.thrift @@ -0,0 +1,58 @@ +# Copyright (c) 2016 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +namespace cpp jaegertracing.sampling_manager.thrift +namespace java io.jaegertracing.thrift.sampling_manager +namespace php Jaeger.Thrift.Agent +namespace netcore Jaeger.Thrift.Agent + +enum SamplingStrategyType { PROBABILISTIC, RATE_LIMITING } + +// ProbabilisticSamplingStrategy randomly samples a fixed percentage of all traces. +struct ProbabilisticSamplingStrategy { + 1: required double samplingRate // percentage expressed as rate (0..1] +} + +// RateLimitingStrategy samples traces with a rate that does not exceed specified number of traces per second. +// The recommended implementation approach is leaky bucket. +struct RateLimitingSamplingStrategy { + 1: required i16 maxTracesPerSecond +} + +// OperationSamplingStrategy defines a sampling strategy that randomly samples a fixed percentage of operation traces. +struct OperationSamplingStrategy { + 1: required string operation + 2: required ProbabilisticSamplingStrategy probabilisticSampling +} + +// PerOperationSamplingStrategies defines a sampling strategy per each operation name in the service +// with a guaranteed lower bound per second. Once the lower bound is met, operations are randomly sampled +// at a fixed percentage. +struct PerOperationSamplingStrategies { + 1: required double defaultSamplingProbability + 2: required double defaultLowerBoundTracesPerSecond + 3: required list<OperationSamplingStrategy> perOperationStrategies + 4: optional double defaultUpperBoundTracesPerSecond +} + +struct SamplingStrategyResponse { + 1: required SamplingStrategyType strategyType + 2: optional ProbabilisticSamplingStrategy probabilisticSampling + 3: optional RateLimitingSamplingStrategy rateLimitingSampling + 4: optional PerOperationSamplingStrategies operationSampling +} + +service SamplingManager { + SamplingStrategyResponse getSamplingStrategy(1: string serviceName) +} diff --git a/src/jaegertracing/jaeger-client-cpp/idl/thrift/zipkincore.thrift b/src/jaegertracing/jaeger-client-cpp/idl/thrift/zipkincore.thrift new file mode 100644 index 000000000..0bcc7b989 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/idl/thrift/zipkincore.thrift @@ -0,0 +1,344 @@ +# Copyright 2012 Twitter Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +namespace cpp twitter.zipkin.thrift +namespace java com.twitter.zipkin.thriftjava +#@namespace scala com.twitter.zipkin.thriftscala +namespace rb Zipkin +namespace php Jaeger.Thrift.Agent.Zipkin +namespace netcore Jaeger.Thrift.Agent.Zipkin + +#************** Annotation.value ************** +/** + * The client sent ("cs") a request to a server. There is only one send per + * span. For example, if there's a transport error, each attempt can be logged + * as a WIRE_SEND annotation. + * + * If chunking is involved, each chunk could be logged as a separate + * CLIENT_SEND_FRAGMENT in the same span. + * + * Annotation.host is not the server. It is the host which logged the send + * event, almost always the client. When logging CLIENT_SEND, instrumentation + * should also log the SERVER_ADDR. + */ +const string CLIENT_SEND = "cs" +/** + * The client received ("cr") a response from a server. There is only one + * receive per span. For example, if duplicate responses were received, each + * can be logged as a WIRE_RECV annotation. + * + * If chunking is involved, each chunk could be logged as a separate + * CLIENT_RECV_FRAGMENT in the same span. + * + * Annotation.host is not the server. It is the host which logged the receive + * event, almost always the client. The actual endpoint of the server is + * recorded separately as SERVER_ADDR when CLIENT_SEND is logged. + */ +const string CLIENT_RECV = "cr" +/** + * The server sent ("ss") a response to a client. There is only one response + * per span. If there's a transport error, each attempt can be logged as a + * WIRE_SEND annotation. + * + * Typically, a trace ends with a server send, so the last timestamp of a trace + * is often the timestamp of the root span's server send. + * + * If chunking is involved, each chunk could be logged as a separate + * SERVER_SEND_FRAGMENT in the same span. + * + * Annotation.host is not the client. It is the host which logged the send + * event, almost always the server. The actual endpoint of the client is + * recorded separately as CLIENT_ADDR when SERVER_RECV is logged. + */ +const string SERVER_SEND = "ss" +/** + * The server received ("sr") a request from a client. There is only one + * request per span. For example, if duplicate responses were received, each + * can be logged as a WIRE_RECV annotation. + * + * Typically, a trace starts with a server receive, so the first timestamp of a + * trace is often the timestamp of the root span's server receive. + * + * If chunking is involved, each chunk could be logged as a separate + * SERVER_RECV_FRAGMENT in the same span. + * + * Annotation.host is not the client. It is the host which logged the receive + * event, almost always the server. When logging SERVER_RECV, instrumentation + * should also log the CLIENT_ADDR. + */ +const string SERVER_RECV = "sr" +/** + * Message send ("ms") is a request to send a message to a destination, usually + * a broker. This may be the only annotation in a messaging span. If WIRE_SEND + * exists in the same span, it follows this moment and clarifies delays sending + * the message, such as batching. + * + * Unlike RPC annotations like CLIENT_SEND, messaging spans never share a span + * ID. For example, "ms" should always be the parent of "mr". + * + * Annotation.host is not the destination, it is the host which logged the send + * event: the producer. When annotating MESSAGE_SEND, instrumentation should + * also tag the MESSAGE_ADDR. + */ +const string MESSAGE_SEND = "ms" +/** + * A consumer received ("mr") a message from a broker. This may be the only + * annotation in a messaging span. If WIRE_RECV exists in the same span, it + * precedes this moment and clarifies any local queuing delay. + * + * Unlike RPC annotations like SERVER_RECV, messaging spans never share a span + * ID. For example, "mr" should always be a child of "ms" unless it is a root + * span. + * + * Annotation.host is not the broker, it is the host which logged the receive + * event: the consumer. When annotating MESSAGE_RECV, instrumentation should + * also tag the MESSAGE_ADDR. + */ +const string MESSAGE_RECV = "mr" +/** + * Optionally logs an attempt to send a message on the wire. Multiple wire send + * events could indicate network retries. A lag between client or server send + * and wire send might indicate queuing or processing delay. + */ +const string WIRE_SEND = "ws" +/** + * Optionally logs an attempt to receive a message from the wire. Multiple wire + * receive events could indicate network retries. A lag between wire receive + * and client or server receive might indicate queuing or processing delay. + */ +const string WIRE_RECV = "wr" +/** + * Optionally logs progress of a (CLIENT_SEND, WIRE_SEND). For example, this + * could be one chunk in a chunked request. + */ +const string CLIENT_SEND_FRAGMENT = "csf" +/** + * Optionally logs progress of a (CLIENT_RECV, WIRE_RECV). For example, this + * could be one chunk in a chunked response. + */ +const string CLIENT_RECV_FRAGMENT = "crf" +/** + * Optionally logs progress of a (SERVER_SEND, WIRE_SEND). For example, this + * could be one chunk in a chunked response. + */ +const string SERVER_SEND_FRAGMENT = "ssf" +/** + * Optionally logs progress of a (SERVER_RECV, WIRE_RECV). For example, this + * could be one chunk in a chunked request. + */ +const string SERVER_RECV_FRAGMENT = "srf" + +#***** BinaryAnnotation.key ****** +/** + * The value of "lc" is the component or namespace of a local span. + * + * BinaryAnnotation.host adds service context needed to support queries. + * + * Local Component("lc") supports three key features: flagging, query by + * service and filtering Span.name by namespace. + * + * While structurally the same, local spans are fundamentally different than + * RPC spans in how they should be interpreted. For example, zipkin v1 tools + * center on RPC latency and service graphs. Root local-spans are neither + * indicative of critical path RPC latency, nor have impact on the shape of a + * service graph. By flagging with "lc", tools can special-case local spans. + * + * Zipkin v1 Spans are unqueryable unless they can be indexed by service name. + * The only path to a service name is by (Binary)?Annotation.host.serviceName. + * By logging "lc", a local span can be queried even if no other annotations + * are logged. + * + * The value of "lc" is the namespace of Span.name. For example, it might be + * "finatra2", for a span named "bootstrap". "lc" allows you to resolves + * conflicts for the same Span.name, for example "finatra/bootstrap" vs + * "finch/bootstrap". Using local component, you'd search for spans named + * "bootstrap" where "lc=finch" + */ +const string LOCAL_COMPONENT = "lc" + +#***** BinaryAnnotation.key where value = [1] and annotation_type = BOOL ****** +/** + * Indicates a client address ("ca") in a span. Most likely, there's only one. + * Multiple addresses are possible when a client changes its ip or port within + * a span. + */ +const string CLIENT_ADDR = "ca" +/** + * Indicates a server address ("sa") in a span. Most likely, there's only one. + * Multiple addresses are possible when a client is redirected, or fails to a + * different server ip or port. + */ +const string SERVER_ADDR = "sa" +/** + * Indicates the remote address of a messaging span, usually the broker. + */ +const string MESSAGE_ADDR = "ma" + +/** + * Indicates the network context of a service recording an annotation with two + * exceptions. + * + * When a BinaryAnnotation, and key is CLIENT_ADDR or SERVER_ADDR, + * the endpoint indicates the source or destination of an RPC. This exception + * allows zipkin to display network context of uninstrumented services, or + * clients such as web browsers. + */ +struct Endpoint { + /** + * IPv4 host address packed into 4 bytes. + * + * Ex for the ip 1.2.3.4, it would be (1 << 24) | (2 << 16) | (3 << 8) | 4 + */ + 1: i32 ipv4 + /** + * IPv4 port + * + * Note: this is to be treated as an unsigned integer, so watch for negatives. + * + * Conventionally, when the port isn't known, port = 0. + */ + 2: i16 port + /** + * Service name in lowercase, such as "memcache" or "zipkin-web" + * + * Conventionally, when the service name isn't known, service_name = "unknown". + */ + 3: string service_name + /** + * IPv6 host address packed into 16 bytes. Ex Inet6Address.getBytes() + */ + 4: optional binary ipv6 +} + +/** + * An annotation is similar to a log statement. It includes a host field which + * allows these events to be attributed properly, and also aggregatable. + */ +struct Annotation { + /** + * Microseconds from epoch. + * + * This value should use the most precise value possible. For example, + * gettimeofday or syncing nanoTime against a tick of currentTimeMillis. + */ + 1: i64 timestamp + 2: string value // what happened at the timestamp? + /** + * Always the host that recorded the event. By specifying the host you allow + * rollup of all events (such as client requests to a service) by IP address. + */ + 3: optional Endpoint host + // don't reuse 4: optional i32 OBSOLETE_duration // how long did the operation take? microseconds +} + +enum AnnotationType { BOOL, BYTES, I16, I32, I64, DOUBLE, STRING } + +/** + * Binary annotations are tags applied to a Span to give it context. For + * example, a binary annotation of "http.uri" could the path to a resource in a + * RPC call. + * + * Binary annotations of type STRING are always queryable, though more a + * historical implementation detail than a structural concern. + * + * Binary annotations can repeat, and vary on the host. Similar to Annotation, + * the host indicates who logged the event. This allows you to tell the + * difference between the client and server side of the same key. For example, + * the key "http.uri" might be different on the client and server side due to + * rewriting, like "/api/v1/myresource" vs "/myresource. Via the host field, + * you can see the different points of view, which often help in debugging. + */ +struct BinaryAnnotation { + 1: string key, + 2: binary value, + 3: AnnotationType annotation_type, + /** + * The host that recorded tag, which allows you to differentiate between + * multiple tags with the same key. There are two exceptions to this. + * + * When the key is CLIENT_ADDR or SERVER_ADDR, host indicates the source or + * destination of an RPC. This exception allows zipkin to display network + * context of uninstrumented services, or clients such as web browsers. + */ + 4: optional Endpoint host +} + +/** + * A trace is a series of spans (often RPC calls) which form a latency tree. + * + * The root span is where trace_id = id and parent_id = Nil. The root span is + * usually the longest interval in the trace, starting with a SERVER_RECV + * annotation and ending with a SERVER_SEND. + */ +struct Span { + 1: i64 trace_id # unique trace id, use for all spans in trace + /** + * Span name in lowercase, rpc method for example + * + * Conventionally, when the span name isn't known, name = "unknown". + */ + 3: string name, + 4: i64 id, # unique span id, only used for this span + 5: optional i64 parent_id, # parent span id + 6: list<Annotation> annotations, # all annotations/events that occured, sorted by timestamp + 8: list<BinaryAnnotation> binary_annotations # any binary annotations + 9: optional bool debug = 0 # if true, we DEMAND that this span passes all samplers + /** + * Microseconds from epoch of the creation of this span. + * + * This value should be set directly by instrumentation, using the most + * precise value possible. For example, gettimeofday or syncing nanoTime + * against a tick of currentTimeMillis. + * + * For compatibilty with instrumentation that precede this field, collectors + * or span stores can derive this via Annotation.timestamp. + * For example, SERVER_RECV.timestamp or CLIENT_SEND.timestamp. + * + * This field is optional for compatibility with old data: first-party span + * stores are expected to support this at time of introduction. + */ + 10: optional i64 timestamp, + /** + * Measurement of duration in microseconds, used to support queries. + * + * This value should be set directly, where possible. Doing so encourages + * precise measurement decoupled from problems of clocks, such as skew or NTP + * updates causing time to move backwards. + * + * For compatibilty with instrumentation that precede this field, collectors + * or span stores can derive this by subtracting Annotation.timestamp. + * For example, SERVER_SEND.timestamp - SERVER_RECV.timestamp. + * + * If this field is persisted as unset, zipkin will continue to work, except + * duration query support will be implementation-specific. Similarly, setting + * this field non-atomically is implementation-specific. + * + * This field is i64 vs i32 to support spans longer than 35 minutes. + */ + 11: optional i64 duration + /** + * Optional unique 8-byte additional identifier for a trace. If non zero, this + * means the trace uses 128 bit traceIds instead of 64 bit. + */ + 12: optional i64 trace_id_high +} + +# define TChannel service + +struct Response { + 1: required bool ok +} + +service ZipkinCollector { + list<Response> submitZipkinBatch(1: list<Span> spans) +} diff --git a/src/jaegertracing/jaeger-client-cpp/scripts/build-plugin.sh b/src/jaegertracing/jaeger-client-cpp/scripts/build-plugin.sh new file mode 100755 index 000000000..192c824d0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/scripts/build-plugin.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +set -e + +function main() { + local project_dir + project_dir="$(git rev-parse --show-toplevel)" + + mkdir -p build + cd build + export CFLAGS="$CFLAGS -march=x86-64" + export CXXFLAGS="$CXXFLAGS -march=x86-64" + + cat <<EOF > export.map +{ + global: + OpenTracingMakeTracerFactory; + local: *; +}; +EOF + + cmake -DCMAKE_BUILD_TYPE=Release \ + -DJAEGERTRACING_PLUGIN=ON \ + -DBUILD_TESTING=ON \ + -DHUNTER_CONFIGURATION_TYPES=Release \ + .. + make -j3 + mv libjaegertracing_plugin.so /libjaegertracing_plugin.so + ./DynamicallyLoadTracerTest /libjaegertracing_plugin.so +} + +main diff --git a/src/jaegertracing/jaeger-client-cpp/scripts/build.sh b/src/jaegertracing/jaeger-client-cpp/scripts/build.sh new file mode 100755 index 000000000..e12e11c97 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/scripts/build.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +# Based on https://github.com/codecov/example-cpp11-cmake/blob/master/run_build.sh. + +set -e + +RED='\033[0;31m' +BLUE='\033[0;34m' +NO_COLOR='\033[0m' +GREEN='\033[0;32m' + +function info() { + echo -e "${GREEN}$1${NO_COLOR}" +} + +function working() { + echo -e "${BLUE}$1${NO_COLOR}" +} + +function main() { + local project_dir + project_dir=$(git rev-parse --show-toplevel) + cd "$project_dir" + + mkdir -p build + cd build + cmake ${CMAKE_OPTIONS} .. + make -j3 UnitTest + info "Running tests..." + ./UnitTest + working "All tests compiled and passed" + + set -x + if ! [[ "${CMAKE_OPTIONS}" =~ "-DJAEGERTRACING_BUILD_CROSSDOCK=ON" ]]; then + exit 0 + fi + make crossdock-fresh +} + +main diff --git a/src/jaegertracing/jaeger-client-cpp/scripts/clang-format.sh b/src/jaegertracing/jaeger-client-cpp/scripts/clang-format.sh new file mode 100755 index 000000000..3f1a43830 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/scripts/clang-format.sh @@ -0,0 +1,21 @@ +#!/bin/bash + +function main() { + local project_dir + project_dir=$(git rev-parse --show-toplevel) + cd "$project_dir" || exit 1 + + local srcs + srcs=$(git ls-files src crossdock | + grep -E -v 'thrift-gen' | + grep -E '\.(cpp|h)$') + + local cmd + for src in $srcs; do + cmd="clang-format -i $src" + echo "$cmd" + eval "$cmd" + done +} + +main diff --git a/src/jaegertracing/jaeger-client-cpp/scripts/clang-tidy.sh b/src/jaegertracing/jaeger-client-cpp/scripts/clang-tidy.sh new file mode 100755 index 000000000..2946db95c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/scripts/clang-tidy.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +function main() { + local project_dir + project_dir=$(git rev-parse --show-toplevel) + cd "$project_dir" || exit 1 + + local srcs + srcs=$(git ls-files src crossdock | + grep -E -v 'thrift-gen|Test\.cpp' | + grep -E '\.cpp$') + + local cmd + for src in $srcs; do + cmd="clang-tidy -p=build" + cmd+=" -checks=\"-clang-diagnostic-unused-command-line-argument\" " + cmd+=" $src" + echo "$cmd" + eval "$cmd" + done +} + +main diff --git a/src/jaegertracing/jaeger-client-cpp/scripts/thrift-gen.patch b/src/jaegertracing/jaeger-client-cpp/scripts/thrift-gen.patch new file mode 100644 index 000000000..aa484888e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/scripts/thrift-gen.patch @@ -0,0 +1,115 @@ +diff --git a/src/jaegertracing/thrift-gen/tracetest_types.cpp b/src/jaegertracing/thrift-gen/tracetest_types.cpp +index cb7199e..ceb7a20 100644 +--- a/src/jaegertracing/thrift-gen/tracetest_types.cpp ++++ b/src/jaegertracing/thrift-gen/tracetest_types.cpp +@@ -60,7 +60,7 @@ void Downstream::__set_transport(const Transport::type val) { + this->transport = val; + } + +-void Downstream::__set_downstream(const Downstream& val) { ++void Downstream::__set_downstream(const std::shared_ptr<Downstream>& val) { + this->downstream = val; + __isset.downstream = true; + } +@@ -141,7 +141,7 @@ uint32_t Downstream::read(::apache::thrift::protocol::TProtocol* iprot) { + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { +- xfer += this->downstream.read(iprot); ++ xfer += this->downstream->read(iprot); + this->__isset.downstream = true; + } else { + xfer += iprot->skip(ftype); +@@ -196,7 +196,7 @@ uint32_t Downstream::write(::apache::thrift::protocol::TProtocol* oprot) const { + + if (this->__isset.downstream) { + xfer += oprot->writeFieldBegin("downstream", ::apache::thrift::protocol::T_STRUCT, 6); +- xfer += this->downstream.write(oprot); ++ xfer += this->downstream->write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); +@@ -672,7 +672,7 @@ void TraceResponse::__set_span(const ObservedSpan& val) { + __isset.span = true; + } + +-void TraceResponse::__set_downstream(const TraceResponse& val) { ++void TraceResponse::__set_downstream(const std::shared_ptr<TraceResponse>& val) { + this->downstream = val; + __isset.downstream = true; + } +@@ -719,7 +719,7 @@ uint32_t TraceResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { +- xfer += this->downstream.read(iprot); ++ xfer += this->downstream->read(iprot); + this->__isset.downstream = true; + } else { + xfer += iprot->skip(ftype); +@@ -759,7 +759,7 @@ uint32_t TraceResponse::write(::apache::thrift::protocol::TProtocol* oprot) cons + } + if (this->__isset.downstream) { + xfer += oprot->writeFieldBegin("downstream", ::apache::thrift::protocol::T_STRUCT, 2); +- xfer += this->downstream.write(oprot); ++ xfer += this->downstream->write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("notImplementedError", ::apache::thrift::protocol::T_STRING, 3); +diff --git a/src/jaegertracing/thrift-gen/tracetest_types.h b/src/jaegertracing/thrift-gen/tracetest_types.h +index 5a0e6c9..a44f3a3 100644 +--- a/src/jaegertracing/thrift-gen/tracetest_types.h ++++ b/src/jaegertracing/thrift-gen/tracetest_types.h +@@ -61,7 +61,7 @@ class Downstream : public virtual ::apache::thrift::TBase { + std::string host; + std::string port; + Transport::type transport; +- Downstream downstream; ++ std::shared_ptr<Downstream> downstream; + + _Downstream__isset __isset; + +@@ -75,7 +75,7 @@ class Downstream : public virtual ::apache::thrift::TBase { + + void __set_transport(const Transport::type val); + +- void __set_downstream(const Downstream& val); ++ void __set_downstream(const std::shared_ptr<Downstream>& val); + + bool operator == (const Downstream & rhs) const + { +@@ -91,7 +91,7 @@ class Downstream : public virtual ::apache::thrift::TBase { + return false; + if (__isset.downstream != rhs.__isset.downstream) + return false; +- else if (__isset.downstream && !(downstream == rhs.downstream)) ++ else if (__isset.downstream && !(*downstream == *rhs.downstream)) + return false; + return true; + } +@@ -273,14 +273,14 @@ class TraceResponse : public virtual ::apache::thrift::TBase { + + virtual ~TraceResponse() throw(); + ObservedSpan span; +- TraceResponse downstream; ++ std::shared_ptr<TraceResponse> downstream; + std::string notImplementedError; + + _TraceResponse__isset __isset; + + void __set_span(const ObservedSpan& val); + +- void __set_downstream(const TraceResponse& val); ++ void __set_downstream(const std::shared_ptr<TraceResponse>& val); + + void __set_notImplementedError(const std::string& val); + +@@ -292,7 +292,7 @@ class TraceResponse : public virtual ::apache::thrift::TBase { + return false; + if (__isset.downstream != rhs.__isset.downstream) + return false; +- else if (__isset.downstream && !(downstream == rhs.downstream)) ++ else if (__isset.downstream && !(*downstream == *rhs.downstream)) + return false; + if (!(notImplementedError == rhs.notImplementedError)) + return false; diff --git a/src/jaegertracing/jaeger-client-cpp/scripts/update-license.py b/src/jaegertracing/jaeger-client-cpp/scripts/update-license.py new file mode 100644 index 000000000..bd51168d0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/scripts/update-license.py @@ -0,0 +1,100 @@ +from __future__ import ( + absolute_import, print_function, division, unicode_literals +) + +import logging +import re +import sys +from datetime import datetime + +logging.basicConfig(level=logging.DEBUG) +logger = logging.getLogger(__name__) + +CURRENT_YEAR = datetime.today().year + +LICENSE_BLOB = """Copyright (c) %d Uber Technologies, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License.""" % CURRENT_YEAR + + +def comment_block(license_blob): + lines = ['/*\n'] + lines += [(' * ' + l).rstrip() + '\n' + for l in license_blob.split('\n')] + lines.append(' */\n') + return lines + + +LICENSE_BLOB_LINES_CPP = comment_block(LICENSE_BLOB) + +COPYRIGHT_RE = re.compile(r'Copyright \(c\) (\d+)', re.I) + + +def update_cpp_license(name, force=False): + with open(name) as f: + orig_lines = list(f) + lines = list(orig_lines) + + found = False + changed = False + for i, line in enumerate(lines[:5]): + m = COPYRIGHT_RE.search(line) + if not m: + continue + + found = True + year = int(m.group(1)) + if year == CURRENT_YEAR: + break + + new_line = COPYRIGHT_RE.sub('Copyright (c) %d' % CURRENT_YEAR, line) + assert line != new_line, ('Could not change year in: %s' % line) + lines[i] = new_line + changed = True + break + + if not found: + if 'Code generated by' in lines[0]: + lines[1:1] = ['\n'] + LICENSE_BLOB_LINES_CPP + else: + lines[0:0] = LICENSE_BLOB_LINES_CPP + ['\n'] + changed = True + + if changed: + with open(name, 'w') as f: + for line in lines: + f.write(line) + print(name) + + +def main(): + if len(sys.argv) == 1: + print('USAGE: %s FILE ...' % sys.argv[0]) + sys.exit(1) + + for name in sys.argv[1:]: + if name.endswith('.cpp') or \ + name.endswith('.h') or \ + name.endswith('.h.in'): + try: + update_cpp_license(name) + except Exception as error: + logger.error('Failed to process file %s', name) + logger.exception(error) + raise error + else: + raise NotImplementedError('Unsupported file type: %s' % name) + + +if __name__ == "__main__": + main() diff --git a/src/jaegertracing/jaeger-client-cpp/scripts/update-licenses.sh b/src/jaegertracing/jaeger-client-cpp/scripts/update-licenses.sh new file mode 100755 index 000000000..e912743ca --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/scripts/update-licenses.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +set -e + +python scripts/update-license.py $(git ls-files "*\.cpp" "*\.h" | + grep -v thrift-gen | + grep -v tracetest) \ + src/jaegertracing/Constants.h.in diff --git a/src/jaegertracing/jaeger-client-cpp/scripts/upload-coverage.sh b/src/jaegertracing/jaeger-client-cpp/scripts/upload-coverage.sh new file mode 100755 index 000000000..a31da5772 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/scripts/upload-coverage.sh @@ -0,0 +1,42 @@ +#!/bin/bash + +# Copyright (c) 2018 Uber Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +set -e + +function main() { + set -x + if ! [[ "${CMAKE_OPTIONS}" =~ "-DJAEGERTRACING_COVERAGE=ON" ]]; then + exit 0 + fi + unset -x + + local project_dir + project_dir=$(git rev-parse --show-toplevel) + cd "$project_dir" || exit 1 + + local gcov_tool + case "$CC" in + gcc*) gcov_tool=${CC/gcc/gcov} + ;; + *) gcov_tool="$project_dir/scripts/llvm-gcov.sh" + ;; + esac + find build -name '*.gcno' -exec "$gcov_tool" {} \; + bash <(curl -s https://codecov.io/bash) || \ + echo "Codecov did not collect coverage reports" +} + +main diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Compilers.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Compilers.h new file mode 100644 index 000000000..9345d08ad --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Compilers.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2019 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_COMPILERS_H +#define JAEGERTRACING_COMPILERS_H + +#ifdef _MSC_VER + +#pragma warning(push) +#pragma warning(disable : 4251) +#pragma warning(disable : 4275) + +// Define NOMINMAX to inhibit definition of Macros min(a,b) and max(a,b) in +// windows.h +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#endif // _MSC_VER + +#endif // JAEGERTRACING_COMPILERS_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Config.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Config.cpp new file mode 100644 index 000000000..abf28bccb --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Config.cpp @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Config.h" +#include "jaegertracing/samplers/Config.h" +#include "jaegertracing/utils/EnvVariable.h" + +namespace jaegertracing { + +constexpr const char* Config::kJAEGER_SERVICE_NAME_ENV_PROP; +constexpr const char* Config::kJAEGER_TAGS_ENV_PROP; +constexpr const char* Config::kJAEGER_JAEGER_DISABLED_ENV_PROP; + +void Config::fromEnv() +{ + const auto disabled = + utils::EnvVariable::getBoolVariable(kJAEGER_JAEGER_DISABLED_ENV_PROP); + if (disabled.first) { + _disabled = disabled.second; + } + + const auto serviceName = + utils::EnvVariable::getStringVariable(kJAEGER_SERVICE_NAME_ENV_PROP); + if (!serviceName.empty()) { + _serviceName = serviceName; + } + + const auto tags = + utils::EnvVariable::getStringVariable(kJAEGER_TAGS_ENV_PROP); + if (!tags.empty()) { + std::string tag; + std::istringstream tagsStream(tags); + while (std::getline(tagsStream, tag, ',')) { + + std::istringstream tagStream(tag); + + std::string tagKey; + std::string tagValue; + if (std::getline(tagStream, tagKey, '=')) { + std::getline(tagStream, tagValue, '='); + if (std::getline(tagStream, tagValue, '=')) { + // error, should be logged somewhere + } + else { + _tags.emplace_back(tagKey, tagValue); + } + } + } + } + _reporter.fromEnv(); + _sampler.fromEnv(); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Config.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Config.h new file mode 100644 index 000000000..2c9f0a32f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Config.h @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_CONFIG_H +#define JAEGERTRACING_CONFIG_H + +#include "jaegertracing/Compilers.h" +#include "jaegertracing/Constants.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/baggage/RestrictionsConfig.h" +#include "jaegertracing/propagation/HeadersConfig.h" +#include "jaegertracing/reporters/Config.h" +#include "jaegertracing/samplers/Config.h" +#include "jaegertracing/utils/YAML.h" + +namespace jaegertracing { + +class Config { + public: + + static constexpr auto kJAEGER_SERVICE_NAME_ENV_PROP = "JAEGER_SERVICE_NAME"; + static constexpr auto kJAEGER_TAGS_ENV_PROP = "JAEGER_TAGS"; + static constexpr auto kJAEGER_JAEGER_DISABLED_ENV_PROP = "JAEGER_DISABLED"; + +#ifdef JAEGERTRACING_WITH_YAML_CPP + + static Config parse(const YAML::Node& configYAML) + { + if (!configYAML.IsDefined() || !configYAML.IsMap()) { + return Config(); + } + + const auto serviceName = + utils::yaml::findOrDefault<std::string>(configYAML, "service_name", ""); + + const auto disabled = + utils::yaml::findOrDefault<bool>(configYAML, "disabled", false); + const auto samplerNode = configYAML["sampler"]; + const auto sampler = samplers::Config::parse(samplerNode); + const auto reporterNode = configYAML["reporter"]; + const auto reporter = reporters::Config::parse(reporterNode); + const auto headersNode = configYAML["headers"]; + const auto headers = propagation::HeadersConfig::parse(headersNode); + const auto baggageRestrictionsNode = configYAML["baggage_restrictions"]; + const auto baggageRestrictions = + baggage::RestrictionsConfig::parse(baggageRestrictionsNode); + return Config( + disabled, sampler, reporter, headers, baggageRestrictions, serviceName); + } + +#endif // JAEGERTRACING_WITH_YAML_CPP + + explicit Config(bool disabled = false, + const samplers::Config& sampler = samplers::Config(), + const reporters::Config& reporter = reporters::Config(), + const propagation::HeadersConfig& headers = + propagation::HeadersConfig(), + const baggage::RestrictionsConfig& baggageRestrictions = + baggage::RestrictionsConfig(), + const std::string& serviceName = "", + const std::vector<Tag>& tags = std::vector<Tag>()) + : _disabled(disabled) + , _serviceName(serviceName) + , _tags(tags) + , _sampler(sampler) + , _reporter(reporter) + , _headers(headers) + , _baggageRestrictions(baggageRestrictions) + { + } + + bool disabled() const { return _disabled; } + + const samplers::Config& sampler() const { return _sampler; } + + const reporters::Config& reporter() const { return _reporter; } + + const propagation::HeadersConfig& headers() const { return _headers; } + + const baggage::RestrictionsConfig& baggageRestrictions() const + { + return _baggageRestrictions; + } + + const std::string& serviceName() const { return _serviceName; } + + const std::vector<Tag>& tags() const { return _tags; } + + void fromEnv(); + + private: + bool _disabled; + std::string _serviceName; + std::vector< Tag > _tags; + samplers::Config _sampler; + reporters::Config _reporter; + propagation::HeadersConfig _headers; + baggage::RestrictionsConfig _baggageRestrictions; +}; + +} // namespace jaegertracing + +#endif // JAEGERTRACING_CONFIG_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ConfigTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ConfigTest.cpp new file mode 100644 index 000000000..225d8e31a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ConfigTest.cpp @@ -0,0 +1,195 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Config.h" +#include "jaegertracing/Constants.h" +#include "jaegertracing/propagation/HeadersConfig.h" +#include "jaegertracing/samplers/Config.h" +#include "jaegertracing/utils/YAML.h" +#include "jaegertracing/testutils/EnvVariable.h" +#include <gtest/gtest.h> + +#include <cstdlib> + +namespace jaegertracing { + +#ifdef JAEGERTRACING_WITH_YAML_CPP + +TEST(Config, testParse) +{ + { + constexpr auto kConfigYAML = R"cfg( +disabled: true +sampler: + type: probabilistic + param: 0.001 +reporter: + queueSize: 100 + bufferFlushInterval: 10 + logSpans: false + localAgentHostPort: 127.0.0.1:6831 +headers: + jaegerDebugHeader: debug-id + jaegerBaggageHeader: baggage + TraceContextHeaderName: trace-id + traceBaggageHeaderPrefix: "testctx-" +baggage_restrictions: + denyBaggageOnInitializationFailure: false + hostPort: 127.0.0.1:5778 + refreshInterval: 60 +)cfg"; + const auto config = Config::parse(YAML::Load(kConfigYAML)); + ASSERT_EQ("probabilistic", config.sampler().type()); + ASSERT_EQ("debug-id", config.headers().jaegerDebugHeader()); + ASSERT_EQ("baggage", config.headers().jaegerBaggageHeader()); + ASSERT_EQ("trace-id", config.headers().traceContextHeaderName()); + ASSERT_EQ("testctx-", config.headers().traceBaggageHeaderPrefix()); + } + + { + Config::parse(YAML::Load(R"cfg( +disabled: false +sampler: 1 +reporter: 2 +headers: 3 +baggage_restrictions: 4 +)cfg")); + } +} + +TEST(Config, testDefaultSamplingProbability) +{ + ASSERT_EQ(samplers::Config::kDefaultSamplingProbability, + Config().sampler().param()); +} + +TEST(Config, testDefaultSamplingServerURL) +{ + ASSERT_EQ("http://127.0.0.1:5778/sampling", + Config().sampler().samplingServerURL()); +} + +TEST(Config, testZeroSamplingParam) +{ + { + constexpr auto kConfigYAML = R"cfg( +sampler: + param: 0 +)cfg"; + const auto config = Config::parse(YAML::Load(kConfigYAML)); + ASSERT_EQ(0, config.sampler().param()); + } +} + +#endif // JAEGERTRACING_WITH_YAML_CPP + +TEST(Config, testFromEnv) +{ + std::vector<Tag> tags; + tags.emplace_back("hostname", std::string("foo")); + tags.emplace_back("my.app.version", std::string("1.2.3")); + + Config config(false, + samplers::Config("probabilistic", + 0.7, + "http://host34:57/sampling", + 0, + samplers::Config::Clock::duration()), + reporters::Config(10, + std::chrono::milliseconds(100), + false, + "host35:77", + "http://host36:56568"), + propagation::HeadersConfig(), + baggage::RestrictionsConfig(), + "test-service", + tags); + + config.fromEnv(); + + ASSERT_EQ(std::string("http://host36:56568"), config.reporter().endpoint()); + ASSERT_EQ(std::string("host35:77"), config.reporter().localAgentHostPort()); + + ASSERT_EQ(10, config.reporter().queueSize()); + ASSERT_EQ(std::chrono::milliseconds(100), + config.reporter().bufferFlushInterval()); + ASSERT_EQ(false, config.reporter().logSpans()); + + ASSERT_EQ(.7, config.sampler().param()); + ASSERT_EQ(std::string("probabilistic"), config.sampler().type()); + + testutils::EnvVariable::setEnv("JAEGER_AGENT_HOST", "host33"); + testutils::EnvVariable::setEnv("JAEGER_AGENT_PORT", "45"); + testutils::EnvVariable::setEnv("JAEGER_ENDPOINT", "http://host34:56567"); + + testutils::EnvVariable::setEnv("JAEGER_REPORTER_MAX_QUEUE_SIZE", "33"); + testutils::EnvVariable::setEnv("JAEGER_REPORTER_FLUSH_INTERVAL", "45"); + testutils::EnvVariable::setEnv("JAEGER_REPORTER_LOG_SPANS", "true"); + + testutils::EnvVariable::setEnv("JAEGER_SAMPLER_TYPE", "remote"); + testutils::EnvVariable::setEnv("JAEGER_SAMPLER_PARAM", "0.33"); + testutils::EnvVariable::setEnv("JAEGER_SAMPLING_ENDPOINT", "http://myagent:1234"); + + testutils::EnvVariable::setEnv("JAEGER_SERVICE_NAME", "AService"); + testutils::EnvVariable::setEnv("JAEGER_TAGS", "hostname=foobar,my.app.version=4.5.6"); + + config.fromEnv(); + + ASSERT_EQ(std::string("http://host34:56567"), config.reporter().endpoint()); + ASSERT_EQ(std::string("host33:45"), config.reporter().localAgentHostPort()); + + ASSERT_EQ(33, config.reporter().queueSize()); + ASSERT_EQ(std::chrono::milliseconds(45), + config.reporter().bufferFlushInterval()); + ASSERT_EQ(true, config.reporter().logSpans()); + + ASSERT_EQ(std::string("remote"), config.sampler().type()); + ASSERT_EQ(0.33, config.sampler().param()); + ASSERT_EQ(std::string("http://myagent:1234"), config.sampler().samplingServerURL()); + + ASSERT_EQ(std::string("AService"), config.serviceName()); + + std::vector<Tag> expectedTags; + expectedTags.emplace_back("hostname", std::string("foo")); + expectedTags.emplace_back("my.app.version", std::string("1.2.3")); + expectedTags.emplace_back("hostname", std::string("foobar")); + expectedTags.emplace_back("my.app.version", std::string("4.5.6")); + ASSERT_EQ(expectedTags, config.tags()); + + ASSERT_EQ(false, config.disabled()); + + testutils::EnvVariable::setEnv("JAEGER_DISABLED", "TRue"); // case-insensitive + testutils::EnvVariable::setEnv("JAEGER_AGENT_PORT", "445"); + + config.fromEnv(); + ASSERT_EQ(true, config.disabled()); + ASSERT_EQ(std::string("host33:445"), + config.reporter().localAgentHostPort()); + + testutils::EnvVariable::setEnv("JAEGER_AGENT_HOST", ""); + testutils::EnvVariable::setEnv("JAEGER_AGENT_PORT", ""); + testutils::EnvVariable::setEnv("JAEGER_ENDPOINT", ""); + testutils::EnvVariable::setEnv("JAEGER_REPORTER_MAX_QUEUE_SIZE", ""); + testutils::EnvVariable::setEnv("JAEGER_REPORTER_FLUSH_INTERVAL", ""); + testutils::EnvVariable::setEnv("JAEGER_REPORTER_LOG_SPANS", ""); + testutils::EnvVariable::setEnv("JAEGER_SAMPLER_PARAM", ""); + testutils::EnvVariable::setEnv("JAEGER_SAMPLER_TYPE", ""); + testutils::EnvVariable::setEnv("JAEGER_SERVICE_NAME", ""); + testutils::EnvVariable::setEnv("JAEGER_TAGS", ""); + testutils::EnvVariable::setEnv("JAEGER_DISABLED", ""); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Constants.h new file mode 100644 index 000000000..d79e708be --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Constants.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_CONSTANTS_H +#define JAEGERTRACING_CONSTANTS_H + +#define JAEGERTRACING_WITH_YAML_CPP + +namespace jaegertracing { + +static constexpr auto kJaegerClientVersion = "C++-0.6.1"; +static constexpr auto kJaegerClientVersionTagKey = "jaeger.version"; +static constexpr auto kJaegerDebugHeader = "jaeger-debug-id"; +static constexpr auto kJaegerBaggageHeader = "jaeger-baggage"; +static constexpr auto kTracerHostnameTagKey = "hostname"; +static constexpr auto kTracerIPTagKey = "ip"; +static constexpr auto kSamplerTypeTagKey = "sampler.type"; +static constexpr auto kSamplerParamTagKey = "sampler.param"; +static constexpr auto kTraceContextHeaderName = "uber-trace-id"; +static constexpr auto kTracerStateHeaderName = kTraceContextHeaderName; +static constexpr auto kTraceBaggageHeaderPrefix = "uberctx-"; +static constexpr auto kSamplerTypeConst = "const"; +static constexpr auto kSamplerTypeRemote = "remote"; +static constexpr auto kSamplerTypeProbabilistic = "probabilistic"; +static constexpr auto kSamplerTypeRateLimiting = "ratelimiting"; +static constexpr auto kSamplerTypeLowerBound = "lowerbound"; + +} // namespace jaegertracing + +#endif // JAEGERTRACING_CONSTANTS_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Constants.h.in b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Constants.h.in new file mode 100644 index 000000000..c5b90f555 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Constants.h.in @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_CONSTANTS_H +#define JAEGERTRACING_CONSTANTS_H + +#cmakedefine JAEGERTRACING_WITH_YAML_CPP + +namespace jaegertracing { + +static constexpr auto kJaegerClientVersion = "C++-@PROJECT_VERSION@"; +static constexpr auto kJaegerClientVersionTagKey = "jaeger.version"; +static constexpr auto kJaegerDebugHeader = "jaeger-debug-id"; +static constexpr auto kJaegerBaggageHeader = "jaeger-baggage"; +static constexpr auto kTracerHostnameTagKey = "hostname"; +static constexpr auto kTracerIPTagKey = "ip"; +static constexpr auto kSamplerTypeTagKey = "sampler.type"; +static constexpr auto kSamplerParamTagKey = "sampler.param"; +static constexpr auto kTraceContextHeaderName = "uber-trace-id"; +static constexpr auto kTracerStateHeaderName = kTraceContextHeaderName; +static constexpr auto kTraceBaggageHeaderPrefix = "uberctx-"; +static constexpr auto kSamplerTypeConst = "const"; +static constexpr auto kSamplerTypeRemote = "remote"; +static constexpr auto kSamplerTypeProbabilistic = "probabilistic"; +static constexpr auto kSamplerTypeRateLimiting = "ratelimiting"; +static constexpr auto kSamplerTypeLowerBound = "lowerbound"; + +} // namespace jaegertracing + +#endif // JAEGERTRACING_CONSTANTS_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/DynamicLoad.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/DynamicLoad.cpp new file mode 100644 index 000000000..6a114774a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/DynamicLoad.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include <cassert> +#include <cstring> +#include <system_error> + +#include <opentracing/dynamic_load.h> + +#include "jaegertracing/Tracer.h" +#include "jaegertracing/TracerFactory.h" + +static int makeTracerFactory(const char* opentracingVersion, + const char* opentracingABIVersion, + const void** errorCategory, + void* errorMessage, + void** tracerFactory) +{ + assert(errorCategory != nullptr); + assert(tracerFactory != nullptr); +#ifndef JAEGERTRACING_WITH_YAML_CPP + *errorCategory = + static_cast<const void*>(&opentracing::dynamic_load_error_category()); + return opentracing::dynamic_load_not_supported_error.value(); +#endif + if (std::strcmp(opentracingABIVersion, OPENTRACING_ABI_VERSION) != 0) { + *errorCategory = static_cast<const void*>( + &opentracing::dynamic_load_error_category()); + return opentracing::incompatible_library_versions_error.value(); + } + + const auto jaegerTracerFactory = new (std::nothrow) jaegertracing::TracerFactory(true); + *tracerFactory = jaegerTracerFactory; + if (*tracerFactory == nullptr) { + *errorCategory = static_cast<const void*>(&std::generic_category()); + return static_cast<int>(std::errc::not_enough_memory); + } + + return 0; +} + +OPENTRACING_DECLARE_IMPL_FACTORY(makeTracerFactory) diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/DynamicallyLoadTracerTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/DynamicallyLoadTracerTest.cpp new file mode 100644 index 000000000..55db6e392 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/DynamicallyLoadTracerTest.cpp @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include <iostream> +#include <string> + +#include <opentracing/dynamic_load.h> + +#include "jaegertracing/Constants.h" + +// Verify that Jaeger's shared library can be dynamically loaded and used +// as a plugin. +int main(int argc, char* argv[]) +{ + if (argc != 2) { + std::cerr << "DynamicLoadTest <tracer-library>\n"; + return -1; + } + const char* library = argv[1]; + std::string errorMessage; + auto tracerFactoryMaybe = + opentracing::DynamicallyLoadTracingLibrary(library, errorMessage); +#ifdef JAEGERTRACING_WITH_YAML_CPP + if (!errorMessage.empty()) { + std::cerr << "Failed to load tracing tracer: " << errorMessage << "\n"; + return -1; + } + if (!tracerFactoryMaybe) { + std::cerr << "Failed to load tracing library: " + << tracerFactoryMaybe.error().message() << "\n"; + return -1; + } +#else + if (tracerFactoryMaybe) { + std::cerr << "Dynamically loading a tracing library should fail " + "without YAML support\n"; + return -1; + } +#endif // JAEGERTRACING_WITH_YAML_CPP + return 0; +} diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/LogRecord.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/LogRecord.cpp new file mode 100644 index 000000000..82748102f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/LogRecord.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/LogRecord.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" + +namespace jaegertracing { +void LogRecord::thrift(thrift::Log& log) const +{ + log.__set_timestamp(std::chrono::duration_cast<std::chrono::microseconds>( + _timestamp.time_since_epoch()) + .count()); + + std::vector<thrift::Tag> fields; + fields.reserve(_fields.size()); + std::transform(std::begin(_fields), + std::end(_fields), + std::back_inserter(fields), + [](const Tag& tag) { + thrift::Tag thriftTag; + tag.thrift(thriftTag); + return thriftTag; + }); + log.__set_fields(fields); +} +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/LogRecord.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/LogRecord.h new file mode 100644 index 000000000..8e67b81fd --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/LogRecord.h @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_LOGRECORD_H +#define JAEGERTRACING_LOGRECORD_H + +#include "jaegertracing/Compilers.h" +#include "jaegertracing/Tag.h" +#include <algorithm> +#include <chrono> +#include <iterator> +#include <type_traits> +#include <vector> + +#include <opentracing/span.h> + +namespace jaegertracing { +namespace thrift { +class Log; +} + +class LogRecord { + public: + using Clock = std::chrono::system_clock; + + LogRecord() + : _timestamp(Clock::now()) + { + } + + template <typename FieldIterator> + LogRecord(const Clock::time_point& timestamp, + FieldIterator first, + FieldIterator last) + : _timestamp(timestamp) + , _fields(first, last) + { + } + + LogRecord(const opentracing::LogRecord& other) + : _timestamp(other.timestamp) + , _fields(other.fields.begin(), other.fields.end()) + { + } + + const Clock::time_point& timestamp() const { return _timestamp; } + + const std::vector<Tag>& fields() const { return _fields; } + + void thrift(thrift::Log& log) const; + + private: + Clock::time_point _timestamp; + std::vector<Tag> _fields; +}; + +} // namespace jaegertracing + +#endif // JAEGERTRACING_LOGRECORD_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Logging.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Logging.cpp new file mode 100644 index 000000000..0e889b4e9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Logging.cpp @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Logging.h" + +#include <iostream> + +namespace jaegertracing { +namespace logging { +namespace { + +class NullLogger : public Logger { + public: + void error(const std::string& /* message */) override {} + + void info(const std::string& /* message */) override {} +}; + +class ConsoleLogger : public Logger { + public: + void error(const std::string& message) override + { + std::cerr << "ERROR: " << message << '\n'; + } + + void info(const std::string& message) override + { + std::cout << "INFO: " << message << '\n'; + } +}; + +} // anonymous namespace + +std::unique_ptr<Logger> nullLogger() +{ + return std::unique_ptr<Logger>(new NullLogger()); +} + +std::unique_ptr<Logger> consoleLogger() +{ + return std::unique_ptr<Logger>(new ConsoleLogger()); +} + +} // namespace logging +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Logging.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Logging.h new file mode 100644 index 000000000..34b57ea52 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Logging.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_LOGGING_H +#define JAEGERTRACING_LOGGING_H + +#include <memory> +#include <string> + +#include "jaegertracing/Compilers.h" + +namespace jaegertracing { +namespace logging { + +class Logger { + public: + virtual ~Logger() = default; + + virtual void error(const std::string& message) = 0; + + virtual void info(const std::string& message) = 0; +}; + +std::unique_ptr<Logger> nullLogger(); + +std::unique_ptr<Logger> consoleLogger(); + +} // namespace logging +} // namespace jaegertracing + +#endif // JAEGERTRACING_LOGGING_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Reference.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Reference.cpp new file mode 100644 index 000000000..a95376a7f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Reference.cpp @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Reference.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" + +namespace jaegertracing { +void Reference::thrift(thrift::SpanRef& spanRef) const +{ + switch (_type) { + case Type::ChildOfRef: { + spanRef.__set_refType(thrift::SpanRefType::CHILD_OF); + } break; + case Type::FollowsFromRef: { + spanRef.__set_refType(thrift::SpanRefType::FOLLOWS_FROM); + } break; + default: { + std::ostringstream oss; + oss << "Invalid span reference type " << static_cast<int>(_type) + << ", context " << _spanContext; + throw std::invalid_argument(oss.str()); + } break; + } + spanRef.__set_traceIdHigh(_spanContext.traceID().high()); + spanRef.__set_traceIdLow(_spanContext.traceID().low()); + spanRef.__set_spanId(_spanContext.spanID()); +} +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Reference.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Reference.h new file mode 100644 index 000000000..52277aea3 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Reference.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_REFERENCE_H +#define JAEGERTRACING_REFERENCE_H + +#include <sstream> +#include <string> + +#include <opentracing/propagation.h> + +#include "jaegertracing/Compilers.h" +#include "jaegertracing/SpanContext.h" + +namespace jaegertracing { +namespace thrift { +class SpanRef; +} + +class Reference { + public: + using Type = opentracing::SpanReferenceType; + + Reference(const SpanContext& spanContext, Type type) + : _spanContext(spanContext) + , _type(type) + { + } + + const SpanContext& spanContext() const { return _spanContext; } + + Type type() const { return _type; } + + void thrift(thrift::SpanRef& spanRef) const; + + private: + SpanContext _spanContext; + Type _type; +}; + +} // namespace jaegertracing + +#endif // JAEGERTRACING_REFERENCE_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ReferenceTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ReferenceTest.cpp new file mode 100644 index 000000000..546613fa1 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ReferenceTest.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Reference.h" +#include "jaegertracing/SpanContext.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" +#include <gtest/gtest.h> +#include <stdexcept> + +namespace jaegertracing { + +TEST(Reference, testThriftConversion) +{ + const SpanContext context; + const Reference childRef(context, Reference::Type::ChildOfRef); + thrift::SpanRef thriftChildRef; + ASSERT_NO_THROW(childRef.thrift(thriftChildRef)); + const Reference followsFromRef(context, Reference::Type::FollowsFromRef); + thrift::SpanRef thriftFollowsFromRef; + ASSERT_NO_THROW(followsFromRef.thrift(thriftFollowsFromRef)); + const Reference invalidRef(context, static_cast<Reference::Type>(-1)); + thrift::SpanRef thriftInvalidRef; + ASSERT_THROW(invalidRef.thrift(thriftInvalidRef), std::invalid_argument); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Sender.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Sender.cpp new file mode 100644 index 000000000..1456bc22d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Sender.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Sender.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Sender.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Sender.h new file mode 100644 index 000000000..176cfd054 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Sender.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SENDER_H +#define JAEGERTRACING_SENDER_H + +#include <stdexcept> +#include <string> + +#include "jaegertracing/Compilers.h" + +namespace jaegertracing { + +class Span; + +class Sender { + public: + class Exception : public std::runtime_error { + public: + Exception(const std::string& what, int numFailed) + : std::runtime_error(what) + , _numFailed(numFailed) + { + } + + int numFailed() const { return _numFailed; } + + private: + int _numFailed; + }; + + virtual ~Sender() = default; + + virtual int append(const Span& span) = 0; + + virtual int flush() = 0; + + virtual void close() = 0; +}; + +} // namespace jaegertracing + +#endif //JAEGERTRACING_SENDER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Span.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Span.cpp new file mode 100644 index 000000000..3a629f4e2 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Span.cpp @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Span.h" +#include "jaegertracing/Tracer.h" +#include "jaegertracing/baggage/BaggageSetter.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" +#include <cassert> +#include <cstdint> +#include <istream> +#include <memory> +#include <opentracing/value.h> + +namespace jaegertracing { +namespace { + +struct SamplingPriorityVisitor { + using result_type = bool; + + bool operator()(bool boolValue) const { return boolValue; } + + bool operator()(double doubleValue) const { return doubleValue > 0; } + + bool operator()(int64_t intValue) const { return intValue > 0; } + + bool operator()(uint64_t uintValue) const { return uintValue > 0; } + + bool operator()(const std::string& str) const + { + std::istringstream iss(str); + auto intValue = 0; + if (!(iss >> intValue)) { + return false; + } + return intValue > 0; + } + + bool operator()(std::nullptr_t) const { return false; } + + bool operator()(const char* str) const + { + return operator()(std::string(str)); + } + + template <typename OtherType> + bool operator()(OtherType) const + { + return false; + } +}; + +} // anonymous namespace + +void Span::SetBaggageItem(opentracing::string_view restrictedKey, + opentracing::string_view value) noexcept +{ + std::lock_guard<std::mutex> lock(_mutex); + const auto& baggageSetter = _tracer->baggageSetter(); + auto baggage = _context.baggage(); + baggageSetter.setBaggage(*this, + baggage, + restrictedKey, + value, + [this](std::vector<Tag>::const_iterator first, + std::vector<Tag>::const_iterator last) { + logFieldsNoLocking(SystemClock::now(), first, last); + }); + _context = _context.withBaggage(baggage); +} + +void Span::FinishWithOptions( + const opentracing::FinishSpanOptions& finishSpanOptions) noexcept +{ + const auto finishTimeSteady = + (finishSpanOptions.finish_steady_timestamp == SteadyClock::time_point()) + ? SteadyClock::now() + : finishSpanOptions.finish_steady_timestamp; + std::shared_ptr<const Tracer> tracer; + { + + std::lock_guard<std::mutex> lock(_mutex); + if (isFinished()) { + // Already finished, so return immediately. + return; + } + _duration = finishTimeSteady - _startTimeSteady; + if (_duration <= SteadyClock::duration()) { + // Enforce minimum duration of 1 tick (1ns on Linux), + // so isFinished() returns true + _duration = SteadyClock::duration(1); + } + + tracer = _tracer; + + std::copy(finishSpanOptions.log_records.begin(), + finishSpanOptions.log_records.end(), + std::back_inserter(_logs)); + } + + // Call `reportSpan` even for non-sampled traces. + if (tracer) { + tracer->reportSpan(*this); + } +} + +const opentracing::Tracer& Span::tracer() const noexcept +{ + std::lock_guard<std::mutex> lock(_mutex); + if (_tracer) { + return *_tracer; + } + auto tracer = opentracing::Tracer::Global(); + assert(tracer); + return *tracer; +} + +std::string Span::serviceName() const noexcept +{ + std::lock_guard<std::mutex> lock(_mutex); + return serviceNameNoLock(); +} + +std::string Span::serviceNameNoLock() const noexcept +{ + if (!_tracer) { + return std::string(); + } + return _tracer->serviceName(); +} + +void Span::setSamplingPriority(const opentracing::Value& value) +{ + SamplingPriorityVisitor visitor; + const auto priority = opentracing::Value::visit(value, visitor); + + std::lock_guard<std::mutex> lock(_mutex); + auto newFlags = _context.flags(); + if (priority) { + newFlags |= static_cast<unsigned char>(SpanContext::Flag::kSampled) | + static_cast<unsigned char>(SpanContext::Flag::kDebug); + } + else { + newFlags &= ~static_cast<unsigned char>(SpanContext::Flag::kSampled); + } + + _context = SpanContext(_context.traceID(), + _context.spanID(), + _context.parentID(), + newFlags, + _context.baggage(), + _context.debugID()); +} + +void Span::thrift(thrift::Span& span) const +{ + std::lock_guard<std::mutex> lock(_mutex); + span.__set_traceIdHigh(_context.traceID().high()); + span.__set_traceIdLow(_context.traceID().low()); + span.__set_spanId(_context.spanID()); + span.__set_parentSpanId(_context.parentID()); + span.__set_operationName(_operationName); + + std::vector<thrift::SpanRef> refs; + refs.reserve(_references.size()); + std::transform(std::begin(_references), + std::end(_references), + std::back_inserter(refs), + [](const Reference& ref) { + thrift::SpanRef thriftRef; + ref.thrift(thriftRef); + return thriftRef; + }); + span.__set_references(refs); + + span.__set_flags(_context.flags()); + span.__set_startTime(std::chrono::duration_cast<std::chrono::microseconds>( + _startTimeSystem.time_since_epoch()) + .count()); + span.__set_duration( + std::chrono::duration_cast<std::chrono::microseconds>(_duration) + .count()); + + std::vector<thrift::Tag> tags; + tags.reserve(_tags.size()); + std::transform(std::begin(_tags), + std::end(_tags), + std::back_inserter(tags), + [](const Tag& tag) { + thrift::Tag thriftTag; + tag.thrift(thriftTag); + return thriftTag; + }); + span.__set_tags(tags); + + std::vector<thrift::Log> logs; + logs.reserve(_logs.size()); + std::transform(std::begin(_logs), + std::end(_logs), + std::back_inserter(logs), + [](const LogRecord& log) { + thrift::Log thriftLog; + log.thrift(thriftLog); + return thriftLog; + }); + span.__set_logs(logs); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Span.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Span.h new file mode 100644 index 000000000..1e5c7b616 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Span.h @@ -0,0 +1,282 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SPAN_H +#define JAEGERTRACING_SPAN_H + +#include <chrono> +#include <memory> +#include <mutex> + +#include <opentracing/span.h> + +#include "jaegertracing/LogRecord.h" +#include "jaegertracing/Reference.h" +#include "jaegertracing/SpanContext.h" +#include "jaegertracing/Tag.h" + +namespace jaegertracing { + +class Tracer; + +namespace thrift { +class Span; +} + +class Span : public opentracing::Span { + public: + using SteadyClock = opentracing::SteadyClock; + using SystemClock = opentracing::SystemClock; + + explicit Span( + const std::shared_ptr<const Tracer>& tracer = nullptr, + const SpanContext& context = SpanContext(), + const std::string& operationName = "", + const SystemClock::time_point& startTimeSystem = SystemClock::now(), + const SteadyClock::time_point& startTimeSteady = SteadyClock::now(), + const std::vector<Tag>& tags = {}, + const std::vector<Reference>& references = {}) + : _tracer(tracer) + , _context(context) + , _operationName(operationName) + , _startTimeSystem(startTimeSystem) + , _startTimeSteady(startTimeSteady) + , _duration() + , _tags(tags) + , _references(references) + { + } + + Span(const Span& span) + { + std::lock(_mutex, span._mutex); + std::lock_guard<std::mutex> lock(_mutex, std::adopt_lock); + std::lock_guard<std::mutex> spanLock(span._mutex, std::adopt_lock); + + _tracer = span._tracer; + _context = span._context; + _operationName = span._operationName; + _startTimeSystem = span._startTimeSystem; + _startTimeSteady = span._startTimeSteady; + _duration = span._duration; + _tags = span._tags; + _logs = span._logs; + _references = span._references; + } + + // Pass-by-value intentional to implement copy-and-swap. + Span& operator=(Span rhs) + { + swap(rhs); + return *this; + } + + ~Span() { Finish(); } + + void swap(Span& span) + { + using std::swap; + + std::lock(_mutex, span._mutex); + std::lock_guard<std::mutex> lock(_mutex, std::adopt_lock); + std::lock_guard<std::mutex> spanLock(span._mutex, std::adopt_lock); + + swap(_tracer, span._tracer); + swap(_context, span._context); + swap(_operationName, span._operationName); + swap(_startTimeSystem, span._startTimeSystem); + swap(_startTimeSteady, span._startTimeSteady); + swap(_duration, span._duration); + swap(_tags, span._tags); + swap(_logs, span._logs); + swap(_references, span._references); + } + + friend void swap(Span& lhs, Span& rhs) { lhs.swap(rhs); } + + void thrift(thrift::Span& span) const; + + template <typename Stream> + void print(Stream& out) const + { + std::lock_guard<std::mutex> lock(_mutex); + out << _context; + } + + std::string operationName() const + { + std::lock_guard<std::mutex> lock(_mutex); + return _operationName; + } + + SystemClock::time_point startTimeSystem() const + { + std::lock_guard<std::mutex> lock(_mutex); + return _startTimeSystem; + } + + SteadyClock::time_point startTimeSteady() const + { + std::lock_guard<std::mutex> lock(_mutex); + return _startTimeSteady; + } + + SteadyClock::duration duration() const + { + std::lock_guard<std::mutex> lock(_mutex); + return _duration; + } + + std::vector<Tag> tags() const + { + std::lock_guard<std::mutex> lock(_mutex); + return _tags; + } + + template <typename... Arg> + void setOperationName(Arg&&... args) + { + SetOperationName(std::forward<Arg>(args)...); + } + + void FinishWithOptions(const opentracing::FinishSpanOptions& + finishSpanOptions) noexcept override; + + void SetOperationName(opentracing::string_view name) noexcept override + { + std::lock_guard<std::mutex> lock(_mutex); + if (isFinished()) { + return; + } + _operationName = name; + } + + void SetTag(opentracing::string_view key, + const opentracing::Value& value) noexcept override + { + if (key == "sampling.priority") { + setSamplingPriority(value); + return; + } + std::lock_guard<std::mutex> lock(_mutex); + if (isFinished() || !_context.isSampled()) { + return; + } + _tags.push_back(Tag(key, value)); + } + + void SetBaggageItem(opentracing::string_view restrictedKey, + opentracing::string_view value) noexcept override; + + std::string BaggageItem(opentracing::string_view restrictedKey) const + noexcept override + { + std::lock_guard<std::mutex> lock(_mutex); + auto itr = _context.baggage().find(restrictedKey); + return (itr == std::end(_context.baggage())) ? std::string() + : itr->second; + } + + void Log(opentracing::SystemTime timestamp, + std::initializer_list< + std::pair<opentracing::string_view, opentracing::Value>> + fieldPairs) noexcept override + { + doLog(timestamp, fieldPairs); + } + + void Log(opentracing::SystemTime timestamp, + const std::vector< + std::pair<opentracing::string_view, opentracing::Value>>& + fieldPairs) noexcept override + { + doLog(timestamp, fieldPairs); + } + + void Log(std::initializer_list< + std::pair<opentracing::string_view, opentracing::Value>> + fieldPairs) noexcept override + { + doLog(SystemClock::now(), fieldPairs); + } + + const SpanContext& context() const noexcept override + { + std::lock_guard<std::mutex> lock(_mutex); + return _context; + } + + const SpanContext& contextNoLock() const noexcept { return _context; } + + const opentracing::Tracer& tracer() const noexcept override; + + std::string serviceName() const noexcept; + + std::string serviceNameNoLock() const noexcept; + + private: + bool isFinished() const { return _duration != SteadyClock::duration(); } + + template <typename FieldIterator> + void logFieldsNoLocking(const std::chrono::system_clock::time_point& timestamp, FieldIterator first, FieldIterator last) noexcept + { + LogRecord log(timestamp, first, last); + _logs.push_back(log); + } + + template <typename Container> + void doLog(opentracing::SystemTime timestamp, Container fieldPairs) noexcept + { + std::lock_guard<std::mutex> lock(_mutex); + if (!_context.isSampled()) { + return; + } + + std::vector<Tag> fields; + fields.reserve(fieldPairs.size()); + std::transform( + std::begin(fieldPairs), + std::end(fieldPairs), + std::back_inserter(fields), + [](const std::pair<opentracing::string_view, opentracing::Value>& + pair) { return Tag(pair.first, pair.second); }); + logFieldsNoLocking(timestamp, std::begin(fields), std::end(fields)); + } + + void setSamplingPriority(const opentracing::Value& value); + + std::shared_ptr<const Tracer> _tracer; + SpanContext _context; + std::string _operationName; + SystemClock::time_point _startTimeSystem; + SteadyClock::time_point _startTimeSteady; + SteadyClock::duration _duration; + std::vector<Tag> _tags; + std::vector<LogRecord> _logs; + std::vector<Reference> _references; + mutable std::mutex _mutex; +}; + +} // namespace jaegertracing + +inline std::ostream& operator<<(std::ostream& out, + const jaegertracing::Span& span) +{ + span.print(out); + return out; +} + +#endif // JAEGERTRACING_SPAN_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContext.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContext.cpp new file mode 100644 index 000000000..effbf11a7 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContext.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/SpanContext.h" + +#include "jaegertracing/utils/HexParsing.h" + +namespace jaegertracing { + +SpanContext SpanContext::fromStream(std::istream& in) +{ + SpanContext spanContext; + spanContext._traceID = TraceID::fromStream(in); + if (!spanContext._traceID.isValid()) { + return SpanContext(); + } + + char ch = '\0'; + if (!in.get(ch) || ch != ':') { + return SpanContext(); + } + + constexpr auto kMaxUInt64Chars = static_cast<size_t>(16); + auto buffer = utils::HexParsing::readSegment(in, kMaxUInt64Chars, ':'); + if (buffer.empty()) { + return SpanContext(); + } + spanContext._spanID = utils::HexParsing::decodeHex<uint64_t>(buffer); + + if (!in.get(ch) || ch != ':') { + return SpanContext(); + } + + buffer = utils::HexParsing::readSegment(in, kMaxUInt64Chars, ':'); + if (buffer.empty()) { + return SpanContext(); + } + spanContext._parentID = utils::HexParsing::decodeHex<uint64_t>(buffer); + + if (!in.get(ch) || ch != ':') { + return SpanContext(); + } + + constexpr auto kMaxByteChars = static_cast<size_t>(2); + buffer = utils::HexParsing::readSegment(in, kMaxByteChars, ':'); + if (buffer.empty()) { + return SpanContext(); + } + spanContext._flags = utils::HexParsing::decodeHex<unsigned char>(buffer); + + in.clear(); + return spanContext; +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContext.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContext.h new file mode 100644 index 000000000..295a7e91a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContext.h @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SPANCONTEXT_H +#define JAEGERTRACING_SPANCONTEXT_H + +#include <iomanip> +#include <iostream> +#include <memory> +#include <mutex> +#include <string> +#include <unordered_map> + +#include <opentracing/span.h> + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/TraceID.h" + +namespace jaegertracing { + +class SpanContext : public opentracing::SpanContext { + public: + using StrMap = std::unordered_map<std::string, std::string>; + + enum class Flag : unsigned char { kSampled = 1, kDebug = 2 }; + + static SpanContext fromStream(std::istream& in); + + SpanContext() + : _traceID(0, 0) + , _spanID(0) + , _parentID(0) + , _flags(0) + , _mutex() + { + } + + SpanContext(const TraceID& traceID, + uint64_t spanID, + uint64_t parentID, + unsigned char flags, + const StrMap& baggage, + const std::string& debugID = "") + : _traceID(traceID) + , _spanID(spanID) + , _parentID(parentID) + , _flags(flags) + , _baggage(baggage) + , _debugID(debugID) + , _mutex() + { + } + + SpanContext(const SpanContext& ctx) + : _traceID(ctx._traceID) + , _spanID(ctx._spanID) + , _parentID(ctx._parentID) + , _flags(ctx._flags) + , _baggage(ctx._baggage) + , _debugID(ctx._debugID) + { + } + + SpanContext& operator=(SpanContext rhs) + { + swap(rhs); + return *this; + } + + void swap(SpanContext& ctx) + { + using std::swap; + swap(_traceID, ctx._traceID); + swap(_spanID, ctx._spanID); + swap(_parentID, ctx._parentID); + swap(_flags, ctx._flags); + swap(_baggage, ctx._baggage); + swap(_debugID, ctx._debugID); + } + + friend void swap(SpanContext& lhs, SpanContext& rhs) { lhs.swap(rhs); } + + const TraceID& traceID() const { return _traceID; } + + uint64_t spanID() const { return _spanID; } + + uint64_t parentID() const { return _parentID; } + + const StrMap& baggage() const { return _baggage; } + + SpanContext withBaggage(const StrMap& baggage) const + { + std::lock_guard<std::mutex> lock(_mutex); + return SpanContext( + _traceID, _spanID, _parentID, _flags, baggage, _debugID); + } + + template <typename Function> + void forEachBaggageItem(Function f) const + { + std::lock_guard<std::mutex> lock(_mutex); + for (auto&& pair : _baggage) { + if (!f(pair.first, pair.second)) { + break; + } + } + } + + template <typename Function> + void forEachBaggageItem(Function f) + { + std::lock_guard<std::mutex> lock(_mutex); + for (auto&& pair : _baggage) { + if (!f(pair.first, pair.second)) { + break; + } + } + } + + unsigned char flags() const { return _flags; } + + const std::string& debugID() const { return _debugID; } + + bool isSampled() const + { + return _flags & static_cast<unsigned char>(Flag::kSampled); + } + + bool isDebug() const + { + return _flags & static_cast<unsigned char>(Flag::kDebug); + } + + bool isDebugIDContainerOnly() const + { + return !_traceID.isValid() && !_debugID.empty(); + } + + bool isValid() const { return _traceID.isValid() && _spanID != 0; } + + template <typename Stream> + void print(Stream& out) const + { + _traceID.print(out); + out << ':' << std::hex << _spanID << ':' << std::hex << _parentID << ':' + << std::hex << static_cast<size_t>(_flags); + } + + void ForeachBaggageItem( + std::function<bool(const std::string& key, const std::string& value)> f) + const override + { + forEachBaggageItem(f); + } + + std::unique_ptr<opentracing::SpanContext> Clone() const noexcept override + { + std::lock_guard<std::mutex> lock(_mutex); + return std::unique_ptr<opentracing::SpanContext>( + new SpanContext(*this)); + } + + friend bool operator==(const SpanContext& lhs, const SpanContext& rhs) + { + { + std::lock(lhs._mutex, rhs._mutex); + std::lock_guard<std::mutex> lhsLock(lhs._mutex, std::adopt_lock); + std::lock_guard<std::mutex> rhsLock(rhs._mutex, std::adopt_lock); + if (lhs._baggage != rhs._baggage) { + return false; + } + } + return lhs._traceID == rhs._traceID && lhs._spanID == rhs._spanID && + lhs._parentID == rhs._parentID && lhs._flags == rhs._flags && + lhs._debugID == rhs._debugID; + } + + friend bool operator!=(const SpanContext& lhs, const SpanContext& rhs) + { + return !operator==(lhs, rhs); + } + + private: + TraceID _traceID; + uint64_t _spanID; + uint64_t _parentID; + unsigned char _flags; + StrMap _baggage; + std::string _debugID; + mutable std::mutex _mutex; // Protects _baggage. +}; + +} // namespace jaegertracing + +inline std::ostream& operator<<(std::ostream& out, + const jaegertracing::SpanContext& spanContext) +{ + spanContext.print(out); + return out; +} + +inline std::istream& operator>>(std::istream& in, + jaegertracing::SpanContext& spanContext) +{ + spanContext = jaegertracing::SpanContext::fromStream(in); + return in; +} + +#endif // JAEGERTRACING_SPANCONTEXT_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContextTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContextTest.cpp new file mode 100644 index 000000000..6eef6b3c9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanContextTest.cpp @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/SpanContext.h" +#include "jaegertracing/TraceID.h" +#include <algorithm> +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace jaegertracing { +namespace { + +struct FromStreamTestCase { + std::string _input; + bool _success; +}; + +} // anonymous namespace + +TEST(SpanContext, testFromStream) +{ + const FromStreamTestCase testCases[] = { + { "", false }, + { "abcd", false }, + { "ABCD", false }, + { "x:1:1:1", false }, + { "1:x:1:1", false }, + { "1:1:x:1", false }, + { "1:1:1:x", false }, + { "01234567890123456789012345678901234:1:1:1", false }, + { "01234567890123456789012345678901:1:1:1", true }, + { "01234_67890123456789012345678901:1:1:1", false }, + { "0123456789012345678901_345678901:1:1:1", false }, + { "1:0123456789012345:1:1", true }, + { "1:01234567890123456:1:1", false }, + { "10000000000000001:1:1:1", true }, + { "10000000000000001:1:1", false }, + { "1:1:1:1", true } + }; + + for (auto&& testCase : testCases) { + SpanContext spanContext; + { + std::stringstream ss; + ss << testCase._input; + spanContext = SpanContext::fromStream(ss); + ASSERT_EQ(testCase._success, spanContext.isValid()) + << "input=" << testCase._input; + } + + SpanContext spanContextFromStreamOp; + { + std::stringstream ss; + ss << testCase._input; + ss >> spanContextFromStreamOp; + } + + ASSERT_EQ(spanContext, spanContextFromStreamOp); + } +} + +TEST(SpanContext, testFormatting) +{ + SpanContext spanContext(TraceID(255, 255), 0, 0, 0, SpanContext::StrMap()); + std::ostringstream oss; + oss << spanContext; + ASSERT_EQ("ff00000000000000ff:0:0:0", oss.str()); +} + +TEST(SpanContext, testBaggage) +{ + const SpanContext spanContext( + TraceID(0, 0), + 0, + 0, + 0, + SpanContext::StrMap({ { "key1", "value1" }, { "key2", "value2" } })); + std::string keyCopy; + std::string valueCopy; + spanContext.ForeachBaggageItem( + [&keyCopy, &valueCopy](const std::string& key, + const std::string& value) { + keyCopy = key; + valueCopy = value; + return false; + }); + ASSERT_TRUE(keyCopy == "key1" || keyCopy == "key2"); + if (keyCopy == "key1") { + ASSERT_EQ("value1", valueCopy); + } + else { + ASSERT_EQ("value2", valueCopy); + } +} + +TEST(SpanContext, testDebug) +{ + const SpanContext spanContext; + ASSERT_FALSE(spanContext.isDebug()); + ASSERT_FALSE(spanContext.isDebugIDContainerOnly()); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanTest.cpp new file mode 100644 index 000000000..2d9a8e3d9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/SpanTest.cpp @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Span.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" +#include <gtest/gtest.h> +#include <string> + +namespace jaegertracing { + +TEST(Span, testThriftConversion) +{ + const Span span; + ASSERT_TRUE(span.serviceName().empty()); + ASSERT_TRUE(span.operationName().empty()); + thrift::Span thriftSpan; + ASSERT_NO_THROW(span.thrift(thriftSpan)); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tag.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tag.cpp new file mode 100644 index 000000000..6e6c80dc4 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tag.cpp @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Tag.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" + +namespace jaegertracing { +class ThriftVisitor { + public: + using result_type = void; + + explicit ThriftVisitor(thrift::Tag& tag) + : _tag(tag) + { + } + + void operator()(const std::string& value) const { setString(value); } + + void operator()(const char* value) const { setString(value); } + + void operator()(double value) const + { + _tag.__set_vType(thrift::TagType::DOUBLE); + _tag.__set_vDouble(value); + } + + void operator()(bool value) const + { + _tag.__set_vType(thrift::TagType::BOOL); + _tag.__set_vBool(value); + } + + void operator()(int64_t value) const { setLong(value); } + + void operator()(uint64_t value) const { setLong(value); } + + template <typename Arg> + void operator()(Arg&& value) const + { + // No-op + } + + private: + void setString(opentracing::string_view value) const + { + _tag.__set_vType(thrift::TagType::STRING); + _tag.__set_vStr(value); + } + + void setLong(int64_t value) const + { + _tag.__set_vType(thrift::TagType::LONG); + _tag.__set_vLong(value); + } + + thrift::Tag& _tag; +}; + +void Tag::thrift(thrift::Tag& tag) const +{ + tag.__set_key(_key); + ThriftVisitor visitor(tag); + opentracing::util::apply_visitor(visitor, _value); +} + +} // namespace jaegertracing
\ No newline at end of file diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tag.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tag.h new file mode 100644 index 000000000..a88047038 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tag.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_TAG_H +#define JAEGERTRACING_TAG_H + +#include "jaegertracing/Compilers.h" + +#include <algorithm> +#include <cstdint> +#include <opentracing/string_view.h> +#include <opentracing/value.h> +#include <opentracing/variant/variant.hpp> +#include <string> + +namespace jaegertracing { +namespace thrift { +class Tag; +} + +class Tag { + public: + using ValueType = opentracing::Value; + + template <typename ValueArg> + Tag(const std::string& key, ValueArg&& value) + : _key(key) + , _value(std::forward<ValueArg>(value)) + { + } + + template <typename ValueArg> + Tag(const std::pair<std::string, ValueArg>& tag_pair) + : _key(tag_pair.first) + , _value(tag_pair.second) + { + } + + bool operator==(const Tag& rhs) const + { + return _key == rhs._key && _value == rhs._value; + } + + const std::string& key() const { return _key; } + + const ValueType& value() const { return _value; } + + void thrift(thrift::Tag& tag) const; + + private: + std::string _key; + ValueType _value; +}; + +} // namespace jaegertracing + +#endif // JAEGERTRACING_TAG_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TagTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TagTest.cpp new file mode 100644 index 000000000..1fc43462b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TagTest.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Tag.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" +#include <gtest/gtest.h> +#include <string> + +namespace jaegertracing { + +TEST(Tag, testThriftConversion) +{ + const Tag tags[] = { { "testBool", true }, + { "testDouble", 0.0 }, + { "testInt64", 0LL }, + { "testUint64", 0ULL }, + { "testStr", std::string{ "test" } }, + { "testNull", nullptr }, + { "testCStr", "test" } }; + + for (auto&& tag : tags) { + thrift::Tag thriftTag; + ASSERT_NO_THROW(tag.thrift(thriftTag)); + } +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftMethods.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftMethods.cpp new file mode 100644 index 000000000..a1dbe1319 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftMethods.cpp @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2019 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/thrift-gen/BaggageRestrictionManager.h" +#include "jaegertracing/thrift-gen/sampling_types.h" + +namespace jaegertracing { + +// trivial constructors of BaggageRestrictionManager thrift generated code are not generated by MSVC +#ifdef _MSC_VER + +namespace thrift { + +BaggageRestrictionManager_getBaggageRestrictions_args:: + BaggageRestrictionManager_getBaggageRestrictions_args( + const BaggageRestrictionManager_getBaggageRestrictions_args& that) + : serviceName(that.serviceName) +{ +} + +BaggageRestrictionManager_getBaggageRestrictions_args& +BaggageRestrictionManager_getBaggageRestrictions_args:: +operator=(const BaggageRestrictionManager_getBaggageRestrictions_args& that) +{ + this->serviceName = that.serviceName; + return *this; +} + +BaggageRestrictionManager_getBaggageRestrictions_result:: + BaggageRestrictionManager_getBaggageRestrictions_result( + const BaggageRestrictionManager_getBaggageRestrictions_result& that) + : success(that.success) + , __isset(that.__isset) +{ +} +BaggageRestrictionManager_getBaggageRestrictions_result& +BaggageRestrictionManager_getBaggageRestrictions_result:: +operator=(const BaggageRestrictionManager_getBaggageRestrictions_result& that) +{ + this->success = that.success; + return *this; +} + +} // namespace thrift + +#endif // MSVC + +namespace sampling_manager { +namespace thrift { + +const std::map<int, const char*>& samplingStrategyType_VALUES_TO_NAMES() +{ + return _SamplingStrategyType_VALUES_TO_NAMES; +} + +} // namespace thrift +} // namespace sampling_manager +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSender.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSender.cpp new file mode 100644 index 000000000..f5557fe5a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSender.cpp @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/ThriftSender.h" + +#include "jaegertracing/Span.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/Tracer.h" +#include <algorithm> +#include <cstdint> +#include <iostream> +#include <iterator> +#include <thrift/transport/TBufferTransports.h> + +#ifdef _MSC_VER +#pragma warning(disable : 4267) // Conversion from unsigned to signed. It + // should not be a problem here. +#endif + +namespace jaegertracing { +namespace net { +class IPAddress; +} // namespace net + +namespace { + +constexpr auto kEmitBatchOverhead = 30; + +} // anonymous namespace + +ThriftSender::ThriftSender(std::unique_ptr<utils::Transport>&& transporter) + : _transporter(std::move(transporter)) + , _maxSpanBytes(0) + , _byteBufferSize(0) + , _processByteSize(0) + , _protocolFactory(_transporter->protocolFactory()) + , _thriftBuffer(new apache::thrift::transport::TMemoryBuffer()) +{ +} + +int ThriftSender::append(const Span& span) +{ + if (_process.serviceName.empty()) { + const auto& tracer = static_cast<const Tracer&>(span.tracer()); + _process.serviceName = tracer.serviceName(); + + const auto& tracerTags = tracer.tags(); + std::vector<thrift::Tag> thriftTags; + thriftTags.reserve(tracerTags.size()); + std::transform(std::begin(tracerTags), + std::end(tracerTags), + std::back_inserter(thriftTags), + [](const Tag& tag) { + thrift::Tag thriftTag; + tag.thrift(thriftTag); + return thriftTag; + }); + _process.__set_tags(thriftTags); + + _processByteSize = calcSizeOfSerializedThrift(_process); + _maxSpanBytes = + _transporter->maxPacketSize() - _processByteSize - kEmitBatchOverhead; + } + thrift::Span jaegerSpan; + span.thrift(jaegerSpan); + const auto spanSize = calcSizeOfSerializedThrift(jaegerSpan); + if (spanSize > _maxSpanBytes) { + std::ostringstream oss; + throw Sender::Exception("Span is too large", 1); + } + + _byteBufferSize += spanSize; + if (_byteBufferSize <= _maxSpanBytes) { + _spanBuffer.push_back(jaegerSpan); + if (_byteBufferSize < _maxSpanBytes) { + return 0; + } + return flush(); + } + + // Flush currently full buffer, then append this span to buffer. + const auto flushed = flush(); + _spanBuffer.push_back(jaegerSpan); + _byteBufferSize = spanSize + _processByteSize; + return flushed; +} + +int ThriftSender::flush() +{ + if (_spanBuffer.empty()) { + return 0; + } + + thrift::Batch batch; + batch.__set_process(_process); + batch.__set_spans(_spanBuffer); + + try { + _transporter->emitBatch(batch); + } catch (const std::system_error& ex) { + std::ostringstream oss; + oss << "Could not send span " << ex.what() + << ", code=" << ex.code().value(); + throw Sender::Exception(oss.str(), _spanBuffer.size()); + } catch (const std::exception& ex) { + std::ostringstream oss; + oss << "Could not send span " << ex.what(); + throw Sender::Exception(oss.str(), _spanBuffer.size()); + } catch (...) { + throw Sender::Exception("Could not send span, unknown error", + _spanBuffer.size()); + } + + resetBuffers(); + + return batch.spans.size(); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSender.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSender.h new file mode 100644 index 000000000..72d69eef4 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSender.h @@ -0,0 +1,80 @@ +/*
+ * Copyright (c) 2017-2018 Uber Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JAEGERTRACING_THRIFTSENDER_H
+#define JAEGERTRACING_THRIFTSENDER_H
+
+#include "jaegertracing/Compilers.h"
+#include "jaegertracing/Span.h"
+#include "jaegertracing/Sender.h"
+#include "jaegertracing/thrift-gen/jaeger_types.h"
+#include "jaegertracing/utils/Transport.h"
+#include <thrift/transport/TBufferTransports.h>
+
+namespace jaegertracing {
+
+class ThriftSender : public Sender {
+ public:
+ ThriftSender(std::unique_ptr<utils::Transport>&& transporter);
+
+ ~ThriftSender() { close(); }
+
+ int append(const Span& span) override;
+
+ int flush() override;
+
+ void close() override { _transporter->close(); }
+
+ protected:
+ void setClient(std::unique_ptr<utils::Transport>&& client)
+ {
+ _transporter = std::move(client);
+ }
+
+ private:
+ void resetBuffers()
+ {
+ _spanBuffer.clear();
+ _byteBufferSize = _processByteSize;
+ }
+
+ template <typename ThriftType>
+ int calcSizeOfSerializedThrift(const ThriftType& base)
+ {
+ _thriftBuffer->resetBuffer();
+ auto _protocol = _protocolFactory->getProtocol(_thriftBuffer);
+ base.write(_protocol.get());
+ uint8_t* data = nullptr;
+ uint32_t size = 0;
+ _thriftBuffer->getBuffer(&data, &size);
+ return size;
+ }
+
+ std::unique_ptr<utils::Transport> _transporter;
+ int _maxSpanBytes;
+ int _byteBufferSize;
+ std::vector<thrift::Span> _spanBuffer;
+ thrift::Process _process;
+ int _processByteSize;
+ std::unique_ptr<apache::thrift::protocol::TProtocolFactory> _protocolFactory;
+ // reuse buffer across serializations of different ThriftType for size
+ // calculation
+ std::shared_ptr<apache::thrift::transport::TMemoryBuffer> _thriftBuffer;
+};
+
+} // namespace jaegertracing
+
+#endif //JAEGERTRACING_THRIFTSENDER_H
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSenderTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSenderTest.cpp new file mode 100644 index 000000000..b5b0b6d6b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/ThriftSenderTest.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <gtest/gtest.h> + +#include "jaegertracing/Tracer.h" +#include "jaegertracing/ThriftSender.h" +#include "jaegertracing/testutils/TracerUtil.h" +#include "jaegertracing/utils/ErrorUtil.h" + +namespace jaegertracing { +namespace { + +class MockUDPSender : public utils::UDPTransporter { + public: + enum class ExceptionType { kSystemError, kException, kString }; + + MockUDPSender(const net::IPAddress& serverAddr, + int maxPacketSize, + ExceptionType type) + : UDPTransporter(serverAddr, maxPacketSize) + , _type(type) + { + } + + private: + void emitBatch(const thrift::Batch& batch) override + { + switch (_type) { + case ExceptionType::kSystemError: + throw std::system_error( + std::make_error_code(std::errc::invalid_argument)); + case ExceptionType::kException: + throw std::exception(); + default: + assert(_type == ExceptionType::kString); + throw "error"; + } + } + + ExceptionType _type; +}; + +class MockThriftSender : public ThriftSender { + public: + MockThriftSender(const net::IPAddress& ip, + int maxPacketSize, + MockUDPSender::ExceptionType type) + : ThriftSender(std::unique_ptr<utils::Transport>(new MockUDPSender(ip, maxPacketSize, type))) + { + } +}; + +} // anonymous namespace + +TEST(ThriftSender, testManyMessages) +{ + const auto handle = testutils::TracerUtil::installGlobalTracer(); + const auto tracer = + std::static_pointer_cast<const Tracer>(opentracing::Tracer::Global()); + + std::unique_ptr<utils::Transport> transporter( + new utils::UDPTransporter(handle->_mockAgent->spanServerAddress(), 0)); + ThriftSender sender( + std::forward<std::unique_ptr<utils::Transport>>(transporter)); + constexpr auto kNumMessages = 2000; + const auto logger = logging::consoleLogger(); + for (auto i = 0; i < kNumMessages; ++i) { + Span span(tracer); + span.SetOperationName("test" + std::to_string(i)); + ASSERT_NO_THROW(sender.append(span)); + } +} + +TEST(ThriftSender, testExceptions) +{ + const auto handle = testutils::TracerUtil::installGlobalTracer(); + const auto tracer = + std::static_pointer_cast<const Tracer>(opentracing::Tracer::Global()); + + Span span(tracer); + span.SetOperationName("test"); + + const MockUDPSender::ExceptionType exceptionTypes[] = { + MockUDPSender::ExceptionType::kSystemError, + MockUDPSender::ExceptionType::kException, + MockUDPSender::ExceptionType::kString + }; + for (auto type : exceptionTypes) { + MockThriftSender mockSender(net::IPAddress::v4("localhost", 0), 0, type); + mockSender.append(span); + ASSERT_THROW(mockSender.flush(), Sender::Exception); + } +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceID.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceID.cpp new file mode 100644 index 000000000..59a5ceb49 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceID.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/TraceID.h" +#include "jaegertracing/utils/HexParsing.h" +#include <iterator> +#include <stddef.h> +#include <string> + +namespace jaegertracing { + +TraceID TraceID::fromStream(std::istream& in) +{ + TraceID traceID; + constexpr auto kMaxChars = static_cast<size_t>(32); + auto buffer = utils::HexParsing::readSegment(in, kMaxChars, ':'); + + if (buffer.empty()) { + return TraceID(); + } + + if (buffer.size() < kMaxChars / 2) { + traceID._low = utils::HexParsing::decodeHex<uint64_t>(buffer); + } + else { + auto beginLowStr = std::end(buffer) - kMaxChars / 2; + const std::string highStr(std::begin(buffer), beginLowStr); + traceID._high = utils::HexParsing::decodeHex<uint64_t>(highStr); + const std::string lowStr(beginLowStr, std::end(buffer)); + traceID._low = utils::HexParsing::decodeHex<uint64_t>(lowStr); + } + + return traceID; +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceID.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceID.h new file mode 100644 index 000000000..867f0c29b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceID.h @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_TRACEID_H +#define JAEGERTRACING_TRACEID_H + +#include <cstdint> +#include <iomanip> +#include <iostream> + +namespace jaegertracing { + +class TraceID { + public: + static TraceID fromStream(std::istream& in); + + TraceID() + : TraceID(0, 0) + { + } + + TraceID(uint64_t high, uint64_t low) + : _high(high) + , _low(low) + { + } + + bool isValid() const { return _high != 0 || _low != 0; } + + template <typename Stream> + void print(Stream& out) const + { + if (_high == 0) { + out << std::hex << _low; + } + else { + out << std::hex << _high << std::setw(16) << std::setfill('0') + << std::hex << _low; + } + } + + uint64_t high() const { return _high; } + + uint64_t low() const { return _low; } + + bool operator==(const TraceID& rhs) const + { + return _high == rhs._high && _low == rhs._low; + } + + private: + uint64_t _high; + uint64_t _low; +}; + +} // namespace jaegertracing + +inline std::ostream& operator<<(std::ostream& out, + const jaegertracing::TraceID& traceID) +{ + traceID.print(out); + return out; +} + +inline std::istream& operator<<(std::istream& in, + jaegertracing::TraceID& traceID) +{ + traceID = jaegertracing::TraceID::fromStream(in); + return in; +} + +#endif // JAEGERTRACING_TRACEID_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceIDTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceIDTest.cpp new file mode 100644 index 000000000..ece21cfee --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TraceIDTest.cpp @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/TraceID.h" +#include <gtest/gtest.h> +#include <sstream> + +namespace jaegertracing { + +TEST(TraceID, testPrint) +{ + std::ostringstream oss; + oss << TraceID(0, 10); + ASSERT_EQ("a", oss.str()); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tracer.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tracer.cpp new file mode 100644 index 000000000..b6037c00d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tracer.cpp @@ -0,0 +1,279 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Tag.h" +#include "jaegertracing/Tracer.h" +#include "jaegertracing/Reference.h" +#include "jaegertracing/TraceID.h" +#include "jaegertracing/samplers/SamplingStatus.h" +#include <algorithm> +#include <cassert> +#include <chrono> +#include <iterator> +#include <opentracing/util.h> +#include <tuple> + +namespace jaegertracing { +namespace { + +using SystemClock = Tracer::SystemClock; +using SteadyClock = Tracer::SteadyClock; +using TimePoints = std::tuple<SystemClock::time_point, SteadyClock::time_point>; + +// An extension of opentracing::SpanReferenceType enum. See jaegertracing::SelfRef(). +const static int SpanReferenceType_JaegerSpecific_SelfRef = 99; + +TimePoints determineStartTimes(const opentracing::StartSpanOptions& options) +{ + if (options.start_system_timestamp == SystemClock::time_point() && + options.start_steady_timestamp == SteadyClock::time_point()) { + return std::make_tuple(SystemClock::now(), SteadyClock::now()); + } + if (options.start_system_timestamp == SystemClock::time_point()) { + return std::make_tuple(opentracing::convert_time_point<SystemClock>( + options.start_steady_timestamp), + options.start_steady_timestamp); + } + if (options.start_steady_timestamp == SteadyClock::time_point()) { + return std::make_tuple(options.start_system_timestamp, + opentracing::convert_time_point<SteadyClock>( + options.start_system_timestamp)); + } + return std::make_tuple(options.start_system_timestamp, + options.start_steady_timestamp); +} + +} // anonymous namespace + +using StrMap = SpanContext::StrMap; + +constexpr int Tracer::kGen128BitOption; + +std::unique_ptr<opentracing::Span> +Tracer::StartSpanWithOptions(string_view operationName, + const opentracing::StartSpanOptions& options) const + noexcept +{ + try { + const auto result = analyzeReferences(options.references); + const auto* parent = result._parent; + const auto* self = result._self; + const auto& references = result._references; + if (self && (parent || !references.empty())) + { + throw std::invalid_argument("Self and references are exclusive. Only one of them can be specified"); + } + + std::vector<Tag> samplerTags; + auto newTrace = false; + SpanContext ctx; + if (!parent || !parent->isValid()) { + newTrace = true; + auto highID = static_cast<uint64_t>(0); + auto lowID = static_cast<uint64_t>(0); + if (self) { + highID = self->traceID().high(); + lowID = self->traceID().low(); + } + else { + if (_options & kGen128BitOption) { + highID = randomID(); + } + lowID = randomID(); + } + const TraceID traceID(highID, lowID); + const auto spanID = self ? self->spanID() : traceID.low(); + const auto parentID = 0; + auto flags = static_cast<unsigned char>(0); + if (parent && parent->isDebugIDContainerOnly()) { + flags |= + (static_cast<unsigned char>(SpanContext::Flag::kSampled) | + static_cast<unsigned char>(SpanContext::Flag::kDebug)); + samplerTags.push_back(Tag(kJaegerDebugHeader, parent->debugID())); + } + else { + const auto samplingStatus = + _sampler->isSampled(traceID, operationName); + if (samplingStatus.isSampled()) { + flags |= + static_cast<unsigned char>(SpanContext::Flag::kSampled); + samplerTags = samplingStatus.tags(); + } + } + ctx = SpanContext(traceID, spanID, parentID, flags, StrMap()); + } + else { + const auto traceID = parent->traceID(); + const auto spanID = randomID(); + const auto parentID = parent->spanID(); + const auto flags = parent->flags(); + ctx = SpanContext(traceID, spanID, parentID, flags, StrMap()); + } + + if (parent && !parent->baggage().empty()) { + ctx = ctx.withBaggage(parent->baggage()); + } + + SystemClock::time_point startTimeSystem; + SteadyClock::time_point startTimeSteady; + std::tie(startTimeSystem, startTimeSteady) = + determineStartTimes(options); + return startSpanInternal(ctx, + operationName, + startTimeSystem, + startTimeSteady, + samplerTags, + options.tags, + newTrace, + references); + } catch (const std::exception& ex) { + std::ostringstream oss; + oss << "Error occurred in Tracer::StartSpanWithOptions: " << ex.what(); + utils::ErrorUtil::logError(*_logger, oss.str()); + return nullptr; + } catch (...) { + utils::ErrorUtil::logError( + *_logger, "Error occurred in Tracer::StartSpanWithOptions"); + return nullptr; + } +} + +std::unique_ptr<Span> +Tracer::startSpanInternal(const SpanContext& context, + const std::string& operationName, + const SystemClock::time_point& startTimeSystem, + const SteadyClock::time_point& startTimeSteady, + const std::vector<Tag>& internalTags, + const std::vector<OpenTracingTag>& tags, + bool newTrace, + const std::vector<Reference>& references) const +{ + std::vector<Tag> spanTags; + spanTags.reserve(tags.size() + internalTags.size()); + std::transform( + std::begin(tags), + std::end(tags), + std::back_inserter(spanTags), + [](const OpenTracingTag& tag) { return Tag(tag.first, tag.second); }); + spanTags.insert( + std::end(spanTags), std::begin(internalTags), std::end(internalTags)); + + std::unique_ptr<Span> span(new Span(shared_from_this(), + context, + operationName, + startTimeSystem, + startTimeSteady, + spanTags, + references)); + + _metrics->spansStarted().inc(1); + if (span->context().isSampled()) { + _metrics->spansSampled().inc(1); + if (newTrace) { + _metrics->tracesStartedSampled().inc(1); + } + } + else { + _metrics->spansNotSampled().inc(1); + if (newTrace) { + _metrics->tracesStartedNotSampled().inc(1); + } + } + + return span; +} + +Tracer::AnalyzedReferences +Tracer::analyzeReferences(const std::vector<OpenTracingRef>& references) const +{ + AnalyzedReferences result; + auto hasParent = false; + const auto* parent = result._parent; + for (auto&& ref : references) { + const auto* ctx = dynamic_cast<const SpanContext*>(ref.second); + + if (!ctx) { + _logger->error("Reference contains invalid type of SpanReference"); + continue; + } + + if (!ctx->isValid() && !ctx->isDebugIDContainerOnly() && + ctx->baggage().empty()) { + continue; + } + + if (static_cast<int>(ref.first) == SpanReferenceType_JaegerSpecific_SelfRef) + { + result._self = ctx; + continue; // not a reference + } + + result._references.emplace_back(Reference(*ctx, ref.first)); + + if (!hasParent) { + parent = ctx; + hasParent = + (ref.first == opentracing::SpanReferenceType::ChildOfRef); + } + } + + if (!hasParent && parent && parent->isValid()) { + // Use `FollowsFromRef` in place of `ChildOfRef`. + hasParent = true; + } + + if (hasParent) { + assert(parent); + result._parent = parent; + } + + return result; +} + +std::shared_ptr<opentracing::Tracer> +Tracer::make(const std::string& serviceName, + const Config& config, + const std::shared_ptr<logging::Logger>& logger, + metrics::StatsFactory& statsFactory, int options) +{ + if (serviceName.empty()) { + throw std::invalid_argument("no service name provided"); + } + + if (config.disabled()) { + return opentracing::MakeNoopTracer(); + } + + auto metrics = std::make_shared<metrics::Metrics>(statsFactory); + std::shared_ptr<samplers::Sampler> sampler( + config.sampler().makeSampler(serviceName, *logger, *metrics)); + std::shared_ptr<reporters::Reporter> reporter( + config.reporter().makeReporter(serviceName, *logger, *metrics)); + return std::shared_ptr<Tracer>(new Tracer(serviceName, + sampler, + reporter, + logger, + metrics, + config.headers(), + config.tags(), + options)); +} + +opentracing::SpanReference SelfRef(const opentracing::SpanContext* span_context) noexcept { + return {static_cast<opentracing::SpanReferenceType>(SpanReferenceType_JaegerSpecific_SelfRef), span_context}; +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tracer.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tracer.h new file mode 100644 index 000000000..8d204267f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/Tracer.h @@ -0,0 +1,317 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_TRACER_H +#define JAEGERTRACING_TRACER_H + +#include <chrono> +#include <memory> +#include <random> +#include <vector> + +#include <opentracing/noop.h> +#include <opentracing/tracer.h> + +#include "jaegertracing/Compilers.h" +#include "jaegertracing/Config.h" +#include "jaegertracing/Constants.h" +#include "jaegertracing/Logging.h" +#include "jaegertracing/Span.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/baggage/BaggageSetter.h" +#include "jaegertracing/baggage/RestrictionManager.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/metrics/NullStatsFactory.h" +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/platform/Hostname.h" +#include "jaegertracing/propagation/Propagator.h" +#include "jaegertracing/reporters/Reporter.h" +#include "jaegertracing/samplers/Sampler.h" +#include "jaegertracing/utils/ErrorUtil.h" + +namespace jaegertracing { + +class Tracer : public opentracing::Tracer, + public std::enable_shared_from_this<Tracer> { + public: + using SteadyClock = Span::SteadyClock; + using SystemClock = Span::SystemClock; + using string_view = opentracing::string_view; + + static constexpr auto kGen128BitOption = 1; + + static std::shared_ptr<opentracing::Tracer> make(const Config& config) + { + return make(config.serviceName(), + config, + std::shared_ptr<logging::Logger>(logging::nullLogger())); + } + + static std::shared_ptr<opentracing::Tracer> + make(const std::string& serviceName, const Config& config) + { + return make(serviceName, + config, + std::shared_ptr<logging::Logger>(logging::nullLogger())); + } + + static std::shared_ptr<opentracing::Tracer> + make(const std::string& serviceName, + const Config& config, + const std::shared_ptr<logging::Logger>& logger) + { + metrics::NullStatsFactory factory; + return make(serviceName, config, logger, factory); + } + static std::shared_ptr<opentracing::Tracer> + make(const std::string& serviceName, + const Config& config, + const std::shared_ptr<logging::Logger>& logger, + metrics::StatsFactory& statsFactory) + { + return make(serviceName, config, logger, statsFactory, 0); + } + static std::shared_ptr<opentracing::Tracer> + make(const std::string& serviceName, + const Config& config, + const std::shared_ptr<logging::Logger>& logger, + metrics::StatsFactory& statsFactory, + int options); + + ~Tracer() { Close(); } + + std::unique_ptr<opentracing::Span> + StartSpanWithOptions(string_view operationName, + const opentracing::StartSpanOptions& options) const + noexcept override; + + opentracing::expected<void> Inject(const opentracing::SpanContext& ctx, + std::ostream& writer) const override + { + const auto* jaegerCtx = dynamic_cast<const SpanContext*>(&ctx); + if (!jaegerCtx) { + return opentracing::make_expected_from_error<void>( + opentracing::invalid_span_context_error); + } + _binaryPropagator.inject(*jaegerCtx, writer); + return opentracing::make_expected(); + } + + opentracing::expected<void> + Inject(const opentracing::SpanContext& ctx, + const opentracing::TextMapWriter& writer) const override + { + const auto* jaegerCtx = dynamic_cast<const SpanContext*>(&ctx); + if (!jaegerCtx) { + return opentracing::make_expected_from_error<void>( + opentracing::invalid_span_context_error); + } + _textPropagator.inject(*jaegerCtx, writer); + return opentracing::make_expected(); + } + + opentracing::expected<void> + Inject(const opentracing::SpanContext& ctx, + const opentracing::HTTPHeadersWriter& writer) const override + { + const auto* jaegerCtx = dynamic_cast<const SpanContext*>(&ctx); + if (!jaegerCtx) { + return opentracing::make_expected_from_error<void>( + opentracing::invalid_span_context_error); + } + _httpHeaderPropagator.inject(*jaegerCtx, writer); + return opentracing::make_expected(); + } + + opentracing::expected<std::unique_ptr<opentracing::SpanContext>> + Extract(std::istream& reader) const override + { + const auto spanContext = _binaryPropagator.extract(reader); + if (spanContext == SpanContext()) { + return std::unique_ptr<opentracing::SpanContext>(); + } + return std::unique_ptr<opentracing::SpanContext>( + new SpanContext(spanContext)); + } + + opentracing::expected<std::unique_ptr<opentracing::SpanContext>> + Extract(const opentracing::TextMapReader& reader) const override + { + const auto spanContext = _textPropagator.extract(reader); + if (spanContext == SpanContext()) { + return std::unique_ptr<opentracing::SpanContext>(); + } + return std::unique_ptr<opentracing::SpanContext>( + new SpanContext(spanContext)); + } + + opentracing::expected<std::unique_ptr<opentracing::SpanContext>> + Extract(const opentracing::HTTPHeadersReader& reader) const override + { + const auto spanContext = _httpHeaderPropagator.extract(reader); + if (spanContext == SpanContext()) { + return std::unique_ptr<opentracing::SpanContext>(); + } + return std::unique_ptr<opentracing::SpanContext>( + new SpanContext(spanContext)); + } + + void Close() noexcept override + { + try { + _reporter->close(); + _sampler->close(); + _restrictionManager->close(); + } catch (...) { + utils::ErrorUtil::logError(*_logger, + "Error occurred in Tracer::Close"); + } + } + + void close() noexcept { Close(); } + + const std::string& serviceName() const { return _serviceName; } + + const std::vector<Tag>& tags() const { return _tags; } + + const baggage::BaggageSetter& baggageSetter() const + { + return _baggageSetter; + } + + void reportSpan(const Span& span) const + { + _metrics->spansFinished().inc(1); + if (span.context().isSampled()) { + _reporter->report(span); + } + } + + private: + Tracer(const std::string& serviceName, + const std::shared_ptr<samplers::Sampler>& sampler, + const std::shared_ptr<reporters::Reporter>& reporter, + const std::shared_ptr<logging::Logger>& logger, + const std::shared_ptr<metrics::Metrics>& metrics, + const propagation::HeadersConfig& headersConfig, + const std::vector<Tag>& tags, + int options) + : _serviceName(serviceName) + , _hostIPv4(net::IPAddress::localIP(AF_INET)) + , _sampler(sampler) + , _reporter(reporter) + , _metrics(metrics) + , _logger(logger) + , _randomNumberGenerator() + , _textPropagator(headersConfig, _metrics) + , _httpHeaderPropagator(headersConfig, _metrics) + , _binaryPropagator(_metrics) + , _tags() + , _restrictionManager(new baggage::DefaultRestrictionManager(0)) + , _baggageSetter(*_restrictionManager, *_metrics) + , _options(options) + { + _tags.push_back(Tag(kJaegerClientVersionTagKey, kJaegerClientVersion)); + + try { + _tags.push_back(Tag(kTracerHostnameTagKey, platform::hostname())); + } catch (const std::system_error&) { + // Ignore hostname error. + } + + if (_hostIPv4 == net::IPAddress()) { + _logger->error("Unable to determine this host's IP address"); + } + else { + _tags.push_back(Tag(kTracerIPTagKey, _hostIPv4.host())); + } + + std::copy(tags.cbegin(), tags.cend(), std::back_inserter(_tags)); + + std::random_device device; + _randomNumberGenerator.seed(device()); + } + + uint64_t randomID() const + { + std::lock_guard<std::mutex> lock(_randomMutex); + auto value = _randomNumberGenerator(); + while (value == 0) { + value = _randomNumberGenerator(); + } + return value; + } + + using OpenTracingTag = std::pair<std::string, opentracing::Value>; + + std::unique_ptr<Span> + startSpanInternal(const SpanContext& context, + const std::string& operationName, + const SystemClock::time_point& startTimeSystem, + const SteadyClock::time_point& startTimeSteady, + const std::vector<Tag>& internalTags, + const std::vector<OpenTracingTag>& tags, + bool newTrace, + const std::vector<Reference>& references) const; + + using OpenTracingRef = std::pair<opentracing::SpanReferenceType, + const opentracing::SpanContext*>; + + struct AnalyzedReferences { + AnalyzedReferences() + : _parent(nullptr) + , _self(nullptr) + , _references() + { + } + + const SpanContext* _parent; + const SpanContext* _self; + std::vector<Reference> _references; + }; + + AnalyzedReferences + analyzeReferences(const std::vector<OpenTracingRef>& references) const; + + std::string _serviceName; + net::IPAddress _hostIPv4; + std::shared_ptr<samplers::Sampler> _sampler; + std::shared_ptr<reporters::Reporter> _reporter; + std::shared_ptr<metrics::Metrics> _metrics; + std::shared_ptr<logging::Logger> _logger; + mutable std::mt19937_64 _randomNumberGenerator; + mutable std::mutex _randomMutex; + propagation::TextMapPropagator _textPropagator; + propagation::HTTPHeaderPropagator _httpHeaderPropagator; + propagation::BinaryPropagator _binaryPropagator; + std::vector<Tag> _tags; + std::unique_ptr<baggage::RestrictionManager> _restrictionManager; + baggage::BaggageSetter _baggageSetter; + int _options; +}; + + +// jaegertracing::SelfRef() returns an opentracing::SpanReference which can be passed to Tracer::StartSpan +// to influence the SpanContext of the newly created span. Specifically, the new span inherits the traceID +// and spanID from the passed SELF reference. It can be used to pass externally generated IDs to the tracer, +// with the purpose of recording spans from data generated elsewhere (e.g. from logs), or by augmenting the +// data of the existing span (Jaeger backend will merge multiple instances of the spans with the same IDs). +// Must be the lone reference, can be used only for root spans +opentracing::SpanReference SelfRef(const opentracing::SpanContext* span_context) noexcept; + +} // namespace jaegertracing + +#endif // JAEGERTRACING_TRACER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactory.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactory.cpp new file mode 100644 index 000000000..fcc709839 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactory.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "TracerFactory.h" + +#include "jaegertracing/Tracer.h" + +namespace jaegertracing { + +opentracing::expected<std::shared_ptr<opentracing::Tracer>> +TracerFactory::MakeTracer(const char* configuration, + std::string& errorMessage) const noexcept try { +#ifndef JAEGERTRACING_WITH_YAML_CPP + errorMessage = + "Failed to construct tracer: Jaeger was not build with yaml support."; + return opentracing::make_unexpected( + std::make_error_code(std::errc::not_supported)); +#else + YAML::Node yaml; + try { + yaml = YAML::Load(configuration); + } catch (const YAML::ParserException& e) { + errorMessage = e.what(); + return opentracing::make_unexpected( + opentracing::configuration_parse_error); + } + + auto tracerConfig = jaegertracing::Config::parse(yaml); + + if (_readFromEnv) { + tracerConfig.fromEnv(); + } + + if (tracerConfig.serviceName().empty()) { + errorMessage = "`service_name` not provided"; + return opentracing::make_unexpected( + opentracing::invalid_configuration_error); + } + + return jaegertracing::Tracer::make(tracerConfig); +#endif // JAEGERTRACING_WITH_YAML_CPP +} catch (const std::bad_alloc&) { + return opentracing::make_unexpected( + std::make_error_code(std::errc::not_enough_memory)); +} catch (const std::exception& e) { + errorMessage = e.what(); + return opentracing::make_unexpected( + opentracing::invalid_configuration_error); +} +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactory.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactory.h new file mode 100644 index 000000000..90428a7d4 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactory.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_TRACER_FACTORY_H +#define JAEGERTRACING_TRACER_FACTORY_H + +#include <opentracing/tracer_factory.h> + +namespace jaegertracing { + +class TracerFactory : public opentracing::TracerFactory { + public: + opentracing::expected<std::shared_ptr<opentracing::Tracer>> + MakeTracer(const char* configuration, std::string& errorMessage) const + noexcept override; + + TracerFactory() + : TracerFactory(false) + { + } + + TracerFactory(bool readFromEnv) + : _readFromEnv(readFromEnv) + { + } + private: + bool _readFromEnv; +}; + +} // namespace jaegertracing + +#endif // JAEGERTRACING_TRACER_FACTORY_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactoryTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactoryTest.cpp new file mode 100644 index 000000000..3ce186b1c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerFactoryTest.cpp @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Tracer.h" +#include "jaegertracing/TracerFactory.h" +#include "jaegertracing/Constants.h" +#include "jaegertracing/testutils/EnvVariable.h" +#include <gtest/gtest.h> + +namespace jaegertracing { +#ifdef JAEGERTRACING_WITH_YAML_CPP +TEST(TracerFactory, testInvalidConfig) +{ + const char* invalidConfigTestCases[] = { "", + "abc: {", + R"({ + "service_name": {} + })" }; + TracerFactory tracerFactory(true); + for (auto&& invalidConfig : invalidConfigTestCases) { + std::string errorMessage; + auto tracerMaybe = + tracerFactory.MakeTracer(invalidConfig, errorMessage); + ASSERT_FALSE(tracerMaybe); + ASSERT_NE(errorMessage, ""); + } +} + +TEST(TracerFactory, testValidConfig) +{ + const char* config = R"( + { + "service_name": "test", + "disabled": true, + "sampler": { + "type": "probabilistic", + "param": 0.001 + }, + "reporter": { + "queueSize": 100, + "bufferFlushInterval": 10, + "logSpans": false, + "localAgentHostPort": "127.0.0.1:6831" + }, + "headers": { + "jaegerDebugHeader": "debug-id", + "jaegerBaggageHeader": "baggage", + "TraceContextHeaderName": "trace-id", + "traceBaggageHeaderPrefix": "testctx-" + }, + "baggage_restrictions": { + "denyBaggageOnInitializationFailure": false, + "hostPort": "127.0.0.1:5778", + "refreshInterval": 60 + } + })"; + TracerFactory tracerFactory(true); + std::string errorMessage; + auto tracerMaybe = tracerFactory.MakeTracer(config, errorMessage); + ASSERT_EQ(errorMessage, ""); + ASSERT_TRUE(tracerMaybe); +} + +TEST(TracerFactory, testWithoutReadFromEnv) +{ + const char* config = ""; + testutils::EnvVariable::setEnv("JAEGER_SERVICE_NAME", "AService"); + TracerFactory tracerFactory(false); + std::string errorMessage; + auto tracerMaybe = tracerFactory.MakeTracer(config, errorMessage); + ASSERT_FALSE(tracerMaybe); + ASSERT_NE(errorMessage, ""); + + testutils::EnvVariable::setEnv("JAEGER_SERVICE_NAME", ""); +} + +TEST(TracerFactory, testWithReadFromEnv) +{ + const char* config = ""; + testutils::EnvVariable::setEnv("JAEGER_SERVICE_NAME", "AService"); + TracerFactory tracerFactory(true); + std::string errorMessage; + auto tracerMaybe = tracerFactory.MakeTracer(config, errorMessage); + ASSERT_EQ(errorMessage, ""); + ASSERT_TRUE(tracerMaybe); + + auto tracer = tracerMaybe.value(); + const auto jaegerTracer = std::dynamic_pointer_cast<jaegertracing::Tracer>(tracer); + ASSERT_EQ(std::string("AService"), jaegerTracer->serviceName()); + + testutils::EnvVariable::setEnv("JAEGER_SERVICE_NAME", ""); +} + +TEST(TracerFactory, testEnvTakesPrecedence) +{ + + const char* config = R"( + { + "service_name": "Ignored" + })"; + testutils::EnvVariable::setEnv("JAEGER_SERVICE_NAME", "test"); + TracerFactory tracerFactory(true); + std::string errorMessage; + auto tracerMaybe = tracerFactory.MakeTracer(config, errorMessage); + ASSERT_EQ(errorMessage, ""); + ASSERT_TRUE(tracerMaybe); + + auto tracer = tracerMaybe.value(); + const auto jaegerTracer = std::dynamic_pointer_cast<jaegertracing::Tracer>(tracer); + ASSERT_EQ(std::string("test"), jaegerTracer->serviceName()); + + testutils::EnvVariable::setEnv("JAEGER_SERVICE_NAME", ""); +} +#else +TEST(TracerFactory, failsWithoutYAML) +{ + const char* config = ""; + TracerFactory tracerFactory(true); + std::string errorMessage; + auto tracerMaybe = tracerFactory.MakeTracer(config, errorMessage); + ASSERT_NE(errorMessage, ""); + ASSERT_FALSE(tracerMaybe); +} +#endif // JAEGERTRACING_WITH_YAML_CPP +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerTest.cpp new file mode 100644 index 000000000..3d5d88893 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/TracerTest.cpp @@ -0,0 +1,555 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Config.h" +#include "jaegertracing/Constants.h" +#include "jaegertracing/Span.h" +#include "jaegertracing/SpanContext.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/TraceID.h" +#include "jaegertracing/Tracer.h" +#include "jaegertracing/baggage/RestrictionsConfig.h" +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/propagation/HeadersConfig.h" +#include "jaegertracing/reporters/Config.h" +#include "jaegertracing/samplers/Config.h" +#include "jaegertracing/testutils/TracerUtil.h" +#include <algorithm> +#include <chrono> +#include <gtest/gtest.h> +#include <iterator> +#include <memory> +#include <opentracing/expected/expected.hpp> +#include <opentracing/noop.h> +#include <opentracing/propagation.h> +#include <opentracing/span.h> +#include <opentracing/string_view.h> +#include <opentracing/tracer.h> +#include <opentracing/util.h> +#include <sstream> +#include <stdexcept> +#include <string> +#include <utility> +#include <vector> + +namespace jaegertracing { + +using StrMap = SpanContext::StrMap; + +namespace { + +class FakeSpanContext : public opentracing::SpanContext { + void ForeachBaggageItem( + std::function<bool(const std::string&, + const std::string&)> /* unused */) const override + { + // Do nothing + } + + virtual std::unique_ptr<SpanContext> Clone() const noexcept override + { + return std::unique_ptr<FakeSpanContext>(new FakeSpanContext()); + } +}; + +template <typename BaseWriter> +struct WriterMock : public BaseWriter { + explicit WriterMock(StrMap& keyValuePairs) + : _keyValuePairs(keyValuePairs) + { + } + + opentracing::expected<void> + Set(opentracing::string_view key, + opentracing::string_view value) const override + { + _keyValuePairs[key] = value; + return opentracing::make_expected(); + } + + StrMap& _keyValuePairs; +}; + +template <typename BaseReader> +struct ReaderMock : public BaseReader { + using Function = + std::function<bool(opentracing::string_view, opentracing::string_view)>; + + explicit ReaderMock(const StrMap& keyValuePairs) + : _keyValuePairs(keyValuePairs) + { + } + + opentracing::expected<void> ForeachKey( + std::function<opentracing::expected<void>(opentracing::string_view, + opentracing::string_view)> f) + const override + { + for (auto&& pair : _keyValuePairs) { + const auto result = f(pair.first, pair.second); + if (!result) { + return result; + } + } + return opentracing::make_expected(); + } + + const StrMap& _keyValuePairs; +}; + +template <typename ClockType> +typename ClockType::duration +absTimeDiff(const typename ClockType::time_point& lhs, + const typename ClockType::time_point& rhs) +{ + return (rhs < lhs) ? (lhs - rhs) : (rhs - lhs); +} + +} // anonymous namespace + +TEST(Tracer, testTracer) +{ + { + + const auto handle = testutils::TracerUtil::installGlobalTracer(); + const auto tracer = + std::static_pointer_cast<Tracer>(opentracing::Tracer::Global()); + + auto tagItr = std::find_if( + std::begin(tracer->tags()), + std::end(tracer->tags()), + [](const Tag& tag) { return tag.key() == kJaegerClientVersionTagKey; }); + ASSERT_NE(std::end(tracer->tags()), tagItr); + ASSERT_TRUE(tagItr->value().is<const char*>()); + ASSERT_EQ("C++-", + static_cast<std::string>(tagItr->value().get<const char*>()) + .substr(0, 4)); + + opentracing::StartSpanOptions options; + options.tags.push_back({ "tag-key", 1.23 }); + + const FakeSpanContext fakeCtx; + options.references.emplace_back(opentracing::SpanReferenceType::ChildOfRef, + &fakeCtx); + const SpanContext emptyCtx(TraceID(), 0, 0, 0, StrMap()); + options.references.emplace_back(opentracing::SpanReferenceType::ChildOfRef, + &emptyCtx); + const SpanContext parentCtx( + TraceID(0xDEAD, 0xBEEF), 0xBEEF, 1234, 0, StrMap()); + options.references.emplace_back(opentracing::SpanReferenceType::ChildOfRef, + &parentCtx); + options.references.emplace_back( + opentracing::SpanReferenceType::FollowsFromRef, &parentCtx); + const SpanContext debugCtx( + TraceID(), + 0, + 0, + static_cast<unsigned char>(SpanContext::Flag::kSampled) | + static_cast<unsigned char>(SpanContext::Flag::kDebug), + StrMap({ { "debug-baggage-key", "debug-baggage-value" } }), + "123"); + options.references.emplace_back(opentracing::SpanReferenceType::ChildOfRef, + &debugCtx); + + const auto& tags = tracer->tags(); + auto itr = + std::find_if(std::begin(tags), std::end(tags), [](const Tag& tag) { + return tag.key() == kTracerIPTagKey; + }); + ASSERT_NE(std::end(tags), itr); + ASSERT_TRUE(itr->value().is<std::string>()); + ASSERT_EQ(net::IPAddress::v4(itr->value().get<std::string>()).host(), + net::IPAddress::localIP(AF_INET).host()); + + std::unique_ptr<Span> span(static_cast<Span*>( + tracer->StartSpanWithOptions("test-operation", options).release())); + ASSERT_TRUE(static_cast<bool>(span)); + ASSERT_EQ(static_cast<opentracing::Tracer*>(tracer.get()), &span->tracer()); + + span->SetOperationName("test-set-operation"); + span->SetTag("tag-key", "tag-value"); + span->SetBaggageItem("test-baggage-item-key", "test baggage item value"); + ASSERT_EQ("test baggage item value", + span->BaggageItem("test-baggage-item-key")); + span->Log({ { "log-bool", true } }); + opentracing::FinishSpanOptions foptions; + opentracing::LogRecord lr{}; + lr.fields = { { "options-log", "yep" } }; + foptions.log_records.push_back(std::move(lr)); + lr.timestamp = opentracing::SystemClock::now(); + span->FinishWithOptions(foptions); + ASSERT_GE(Span::SteadyClock::now(), + span->startTimeSteady() + span->duration()); + span->SetOperationName("test-set-operation-after-finish"); + ASSERT_EQ("test-set-operation", span->operationName()); + span->SetTag("tagged-after-finish-key", "tagged-after-finish-value"); + + span.reset(static_cast<Span*>( + tracer->StartSpanWithOptions("test-span-with-default-options", {}) + .release())); + + options.references.clear(); + options.references.emplace_back( + opentracing::SpanReferenceType::FollowsFromRef, &parentCtx); + span.reset(static_cast<Span*>( + tracer->StartSpanWithOptions("test-span-with-default-options", options) + .release())); + + options.references.clear(); + options.references.emplace_back(opentracing::SpanReferenceType::ChildOfRef, + &debugCtx); + span.reset(static_cast<Span*>( + tracer->StartSpanWithOptions("test-span-with-debug-parent", options) + .release())); + + options.references.clear(); + options.references.emplace_back( + opentracing::SpanReferenceType::FollowsFromRef, &parentCtx); + options.start_steady_timestamp = Tracer::SteadyClock::now(); + span.reset(static_cast<Span*>( + tracer + ->StartSpanWithOptions("test-span-with-default-system-timestamp", + options) + .release())); + /* + TODO: https://github.com/jaegertracing/jaeger-client-cpp/issues/167 + const auto calculatedSystemTime = + static_cast<Tracer::SystemClock::time_point>( + opentracing::convert_time_point<Tracer::SystemClock>( + span->startTimeSteady())); + ASSERT_GE(std::chrono::milliseconds(10), + absTimeDiff<Tracer::SystemClock>(span->startTimeSystem(), + calculatedSystemTime)); + */ + options.start_system_timestamp = Tracer::SystemClock::now(); + span.reset(static_cast<Span*>( + tracer + ->StartSpanWithOptions("test-span-with-default-steady-timestamp", + options) + .release())); + const auto calculatedSteadyTime = + static_cast<Tracer::SteadyClock::time_point>( + opentracing::convert_time_point<Tracer::SteadyClock>( + span->startTimeSystem())); + /* + TODO: https://github.com/jaegertracing/jaeger-client-cpp/issues/167 + ASSERT_GE(std::chrono::milliseconds(10), + absTimeDiff<Tracer::SteadyClock>(span->startTimeSteady(), + calculatedSteadyTime)); + +*/ options.start_system_timestamp = Tracer::SystemClock::now(); + options.start_steady_timestamp = Tracer::SteadyClock::now(); + span.reset(static_cast<Span*>( + tracer->StartSpanWithOptions("test-span-with-both-timestamps", options) + .release())); + // TODO: https://github.com/jaegertracing/jaeger-client-cpp/issues/167 + + // ASSERT_EQ(options.start_system_timestamp, span->startTimeSystem()); + // ASSERT_EQ(options.start_steady_timestamp, span->startTimeSteady()); + + span.reset(); + + // TODO: https://github.com/jaegertracing/jaeger-client-cpp/issues/127 + + // There is a problem here. After replacing the global tracer, the spans + // produced hold the last references to the tracer. After they are + // published, the tracer is destroyed. This is not the right moment to close + // the tracer. + tracer->Close(); + opentracing::Tracer::InitGlobal(opentracing::MakeNoopTracer()); + } + //std::this_thread::sleep_for(std::chrono::milliseconds(10000)); +} + +TEST(Tracer, testDebugSpan) +{ + const auto handle = testutils::TracerUtil::installGlobalTracer(); + const auto tracer = + std::static_pointer_cast<Tracer>(opentracing::Tracer::Global()); + + // we force span sampling and require debug-id as the extracted + // jaeger-debug-id correlation value. + std::string correlationID = "debug-id"; + + StrMap headers ={ + {kJaegerDebugHeader, correlationID}, + }; + + WriterMock<opentracing::HTTPHeadersWriter> headerWriter(headers); + ReaderMock<opentracing::HTTPHeadersReader> headerReader(headers); + + const FakeSpanContext fakeCtx; + tracer->Inject(fakeCtx, headerWriter); + auto ext = tracer->Extract(headerReader); + + const SpanContext* ctx = dynamic_cast<SpanContext*>(ext->release()); + opentracing::StartSpanOptions opts; + opts.references.emplace_back(opentracing::SpanReferenceType::ChildOfRef, ctx); + + auto otspan = tracer->StartSpanWithOptions("name", opts); + // downcast to jaegertracing span implementation so we can inspect tags + const std::unique_ptr<Span> span(dynamic_cast<Span*>(otspan.release())); + + const auto& spanTags = span->tags(); + auto spanItr = + std::find_if(std::begin(spanTags), std::end(spanTags), [](const Tag& tag) { + return tag.key() == kJaegerDebugHeader; + }); + ASSERT_NE(std::end(spanTags), spanItr); + ASSERT_TRUE(spanItr->value().is<std::string>()); + ASSERT_EQ(spanItr->value().get<std::string>(), correlationID); + + tracer->Close(); + opentracing::Tracer::InitGlobal(opentracing::MakeNoopTracer()); +} + +TEST(Tracer, testConstructorFailure) +{ + Config config; + ASSERT_THROW(Tracer::make("", config), std::invalid_argument); +} + +TEST(Tracer, testDisabledConfig) +{ + Config config(true, + samplers::Config(), + reporters::Config(), + propagation::HeadersConfig(), + baggage::RestrictionsConfig()); + ASSERT_FALSE(static_cast<bool>(std::dynamic_pointer_cast<Tracer>( + Tracer::make("test-service", config)))); +} + +TEST(Tracer, testPropagation) +{ + const auto handle = testutils::TracerUtil::installGlobalTracer(); + const auto tracer = + std::static_pointer_cast<Tracer>(opentracing::Tracer::Global()); + const std::unique_ptr<Span> span(static_cast<Span*>( + tracer->StartSpanWithOptions("test-inject", {}).release())); + span->SetBaggageItem("test-baggage-item-key", "test baggage item value"); + + // Binary + { + std::stringstream ss; + ASSERT_TRUE(static_cast<bool>(tracer->Inject(span->context(), ss))); + auto result = tracer->Extract(ss); + ASSERT_TRUE(static_cast<bool>(result)); + std::unique_ptr<const SpanContext> extractedCtx( + static_cast<SpanContext*>(result->release())); + ASSERT_TRUE(static_cast<bool>(extractedCtx)); + ASSERT_EQ(span->context(), *extractedCtx); + FakeSpanContext fakeCtx; + ss.clear(); + ss.str(""); + ASSERT_FALSE(static_cast<bool>(tracer->Inject(fakeCtx, ss))); + } + + // Text map + { + StrMap textMap; + WriterMock<opentracing::TextMapWriter> textWriter(textMap); + ASSERT_TRUE( + static_cast<bool>(tracer->Inject(span->context(), textWriter))); + ASSERT_EQ(2, textMap.size()); + std::ostringstream oss; + oss << span->context(); + ASSERT_EQ(oss.str(), textMap.at(kTraceContextHeaderName)); + ASSERT_EQ("test baggage item value", + textMap.at(std::string(kTraceBaggageHeaderPrefix) + + "test-baggage-item-key")); + ReaderMock<opentracing::TextMapReader> textReader(textMap); + auto result = tracer->Extract(textReader); + ASSERT_TRUE(static_cast<bool>(result)); + std::unique_ptr<const SpanContext> extractedCtx( + static_cast<SpanContext*>(result->release())); + ASSERT_TRUE(static_cast<bool>(extractedCtx)); + ASSERT_EQ(span->context(), *extractedCtx); + } + + // HTTP map + { + StrMap headerMap; + WriterMock<opentracing::HTTPHeadersWriter> headerWriter(headerMap); + ASSERT_TRUE( + static_cast<bool>(tracer->Inject(span->context(), headerWriter))); + ASSERT_EQ(2, headerMap.size()); + std::ostringstream oss; + oss << span->context(); + ASSERT_EQ(oss.str(), headerMap.at(kTraceContextHeaderName)); + ASSERT_EQ("test%20baggage%20item%20value", + headerMap.at(std::string(kTraceBaggageHeaderPrefix) + + "test-baggage-item-key")); + ReaderMock<opentracing::HTTPHeadersReader> headerReader(headerMap); + auto result = tracer->Extract(headerReader); + ASSERT_TRUE(static_cast<bool>(result)); + std::unique_ptr<const SpanContext> extractedCtx( + static_cast<SpanContext*>(result->release())); + ASSERT_TRUE(static_cast<bool>(extractedCtx)); + ASSERT_EQ(span->context(), *extractedCtx); + + // Test debug header. + headerMap.clear(); + headerMap[kJaegerDebugHeader] = "yes"; + tracer->Inject(span->context(), headerWriter); + result = tracer->Extract(headerReader); + ASSERT_TRUE(static_cast<bool>(result)); + extractedCtx.reset(static_cast<SpanContext*>(result->release())); + ASSERT_TRUE(static_cast<bool>(extractedCtx)); + ASSERT_NE(span->context(), *extractedCtx); + SpanContext ctx( + span->context().traceID(), + span->context().spanID(), + span->context().parentID(), + span->context().flags() | + static_cast<unsigned char>(SpanContext::Flag::kDebug), + span->context().baggage(), + "yes"); + ASSERT_EQ(ctx, *extractedCtx); + + // Test bad trace context. + headerMap.clear(); + headerMap[kTraceContextHeaderName] = "12345678"; + result = tracer->Extract(headerReader); + ASSERT_TRUE(static_cast<bool>(result)); + extractedCtx.reset(static_cast<SpanContext*>(result->release())); + ASSERT_EQ(nullptr, extractedCtx.get()); + + // Test empty map. + headerMap.clear(); + result = tracer->Extract(headerReader); + ASSERT_TRUE(static_cast<bool>(result)); + extractedCtx.reset(static_cast<SpanContext*>(result->release())); + ASSERT_EQ(nullptr, extractedCtx.get()); + + // Test alternative baggage format. + headerMap.clear(); + ctx = SpanContext(span->context().traceID(), + span->context().spanID(), + span->context().parentID(), + span->context().flags(), + { { "a", "x" }, { "b", "y" }, { "c", "z" } }); + tracer->Inject(ctx, headerWriter); + for (auto itr = std::begin(headerMap); itr != std::end(headerMap);) { + if (itr->first.substr(0, std::strlen(kTraceBaggageHeaderPrefix)) == + kTraceBaggageHeaderPrefix) { + itr = headerMap.erase(itr); + } + else { + ++itr; + } + } + headerMap[kJaegerBaggageHeader] = "a=x,b=y,c=z"; + result = tracer->Extract(headerReader); + ASSERT_TRUE(static_cast<bool>(result)); + extractedCtx.reset(static_cast<SpanContext*>(result->release())); + ASSERT_TRUE(static_cast<bool>(extractedCtx)); + ASSERT_EQ(3, extractedCtx->baggage().size()); + ASSERT_EQ(ctx, *extractedCtx); + } + tracer->Close(); +} + +TEST(Tracer, testTracerTags) +{ + std::vector<Tag> tags; + tags.emplace_back("hostname", std::string("foobar")); + tags.emplace_back("my.app.version", std::string("1.2.3")); + + Config config( + false, + samplers::Config( + "const", 1, "", 0, samplers::Config::Clock::duration()), + reporters::Config(0, std::chrono::milliseconds(100), false, "", ""), + propagation::HeadersConfig(), + baggage::RestrictionsConfig(), + "test-service", + tags); + + auto tracer = Tracer::make(config); + const auto jaegerTracer = std::static_pointer_cast<Tracer>(tracer); + + ASSERT_TRUE(std::find(jaegerTracer->tags().begin(), + jaegerTracer->tags().end(), + Tag("hostname", std::string("foobar"))) != + jaegerTracer->tags().end()); + + ASSERT_TRUE(std::find(jaegerTracer->tags().begin(), + jaegerTracer->tags().end(), + Tag("my.app.version", std::string("1.2.3"))) != + jaegerTracer->tags().end()); + + ASSERT_EQ(std::string("test-service"), jaegerTracer->serviceName()); +} + +TEST(Tracer, testTracerSimpleChild) +{ + const auto handle = testutils::TracerUtil::installGlobalTracer(); + const auto tracer = std::static_pointer_cast<Tracer>(opentracing::Tracer::Global()); + { + auto spanRoot = tracer->StartSpan("test-simple-root"); + ASSERT_TRUE(spanRoot); + auto spanChild = tracer->StartSpan("test-simple-child", + { opentracing::ChildOf(&spanRoot->context()) }); + ASSERT_TRUE(spanChild); + } + tracer->Close(); +} + +TEST(Tracer, testTracerSpanSelfRef) +{ + const auto handle = testutils::TracerUtil::installGlobalTracer(); + const auto tracer = std::static_pointer_cast<Tracer>(opentracing::Tracer::Global()); + { + const jaegertracing::SpanContext spanSelfContext { {1, 2}, 3, 0, 0, jaegertracing::SpanContext::StrMap() }; + auto spanRoot = tracer->StartSpan("test-root-self-ref", {jaegertracing::SelfRef(&spanSelfContext)}); + ASSERT_TRUE(spanRoot); + auto jaegerSpanRoot = dynamic_cast<jaegertracing::Span&>(*spanRoot.get()); + ASSERT_EQ(jaegerSpanRoot.context().traceID(), jaegertracing::TraceID(1, 2)); + ASSERT_EQ(jaegerSpanRoot.context().spanID(), 3); + + auto spanChild = tracer->StartSpan("test-child-self-ref", + { opentracing::ChildOf(&spanRoot->context()) }); + ASSERT_TRUE(spanChild); + auto jaegerSpanChild = dynamic_cast<jaegertracing::Span&>(*spanChild.get()); + ASSERT_EQ(jaegerSpanChild.context().traceID(), jaegertracing::TraceID(1, 2)); + ASSERT_NE(jaegerSpanChild.context().spanID(), 3); + } + tracer->Close(); +} + +TEST(Tracer, testTracerSpanSelfRefWithOtherRefs) +{ + const auto handle = testutils::TracerUtil::installGlobalTracer(); + const auto tracer = std::static_pointer_cast<Tracer>(opentracing::Tracer::Global()); + { + const jaegertracing::SpanContext spanSelfContext { {1, 2}, 3, 0, 0, jaegertracing::SpanContext::StrMap() }; + auto spanRoot = tracer->StartSpan("test-root-self-ref", {jaegertracing::SelfRef(&spanSelfContext)}); + ASSERT_TRUE(spanRoot); + auto jaegerSpanRoot = dynamic_cast<jaegertracing::Span&>(*spanRoot.get()); + ASSERT_EQ(jaegerSpanRoot.context().traceID(), jaegertracing::TraceID(1, 2)); + ASSERT_EQ(jaegerSpanRoot.context().spanID(), 3); + + const jaegertracing::SpanContext spanSelfContext2 { {1, 2}, 4, 0, 0, jaegertracing::SpanContext::StrMap() }; + auto spanChild = tracer->StartSpan("test-child-self-ref", + { opentracing::ChildOf(&spanRoot->context()), jaegertracing::SelfRef(&spanSelfContext2) } + ); + ASSERT_FALSE(spanChild); + } + tracer->Close(); +} + +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageSetter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageSetter.cpp new file mode 100644 index 000000000..8f6b5493c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageSetter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/baggage/BaggageSetter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageSetter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageSetter.h new file mode 100644 index 000000000..fb4fd56c3 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageSetter.h @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_BAGGAGE_BAGGAGESETTER_H +#define JAEGERTRACING_BAGGAGE_BAGGAGESETTER_H + +#include "jaegertracing/LogRecord.h" +#include "jaegertracing/Span.h" +#include "jaegertracing/baggage/RestrictionManager.h" +#include "jaegertracing/metrics/Metrics.h" + +namespace jaegertracing { +namespace baggage { + +class BaggageSetter { + public: + BaggageSetter(RestrictionManager& restrictionManager, + metrics::Metrics& metrics) + : _restrictionManager(restrictionManager) + , _metrics(metrics) + { + } + + template <typename LoggingFunction> + void setBaggage(Span& span, + SpanContext::StrMap& baggage, + const std::string& key, + std::string value, + LoggingFunction logFn) const + { + auto truncated = false; + const auto restriction = + _restrictionManager.getRestriction(span.serviceNameNoLock(), key); + if (!restriction.keyAllowed()) { + logFields(span, + key, + value, + std::string(), + truncated, + restriction.keyAllowed(), + logFn); + _metrics.baggageUpdateFailure().inc(1); + return; + } + + if (static_cast<int>(value.size()) > restriction.maxValueLength()) { + truncated = true; + value = value.substr(0, restriction.maxValueLength()); + _metrics.baggageTruncate().inc(1); + } + + auto itr = baggage.find(key); + const auto prevItem = + (itr == std::end(baggage) ? std::string() : itr->second); + if (itr == std::end(baggage)) { + baggage[key] = value; + } + else { + itr->second = value; + } + logFields(span, + key, + value, + prevItem, + truncated, + restriction.keyAllowed(), + logFn); + _metrics.baggageUpdateSuccess().inc(1); + } + + private: + template <typename LoggingFunction> + void logFields(const Span& span, + const std::string& key, + const std::string& value, + const std::string& prevItem, + bool truncated, + bool valid, + LoggingFunction logFn) const + { + if (!span.contextNoLock().isSampled()) { + return; + } + + std::vector<Tag> fields( + { { "event", "baggage" }, { "key", key }, { "value", value } }); + if (!prevItem.empty()) { + fields.push_back(Tag("override", "true")); + } + if (truncated) { + fields.push_back(Tag("truncated", "true")); + } + if (!valid) { + fields.push_back(Tag("invalid", "true")); + } + + logFn(std::begin(fields), std::end(fields)); + } + + RestrictionManager& _restrictionManager; + metrics::Metrics& _metrics; +}; + +} // namespace baggage +} // namespace jaegertracing + +#endif // JAEGERTRACING_BAGGAGE_BAGGAGESETTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageTest.cpp new file mode 100644 index 000000000..3c122cdcf --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/BaggageTest.cpp @@ -0,0 +1,181 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <gtest/gtest.h> + +#include "jaegertracing/baggage/BaggageSetter.h" +#include "jaegertracing/baggage/RemoteRestrictionManager.h" +#include "jaegertracing/baggage/RestrictionManager.h" +#include "jaegertracing/baggage/RestrictionsConfig.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/metrics/InMemoryStatsReporter.h" +#include "jaegertracing/testutils/MockAgent.h" + +#include <mutex> + +namespace jaegertracing { +namespace baggage { +namespace { + +class TestStatsReporter : public metrics::StatsReporter { + public: + + using ValueMap = std::unordered_map<std::string, int64_t>; + + virtual ~TestStatsReporter() = default; + + void incCounter(const std::string& name, + int64_t delta, + const metrics::StatsReporter::TagMap& tags) override + { + std::lock_guard<std::mutex> lock(_mutex); + + const auto metricName = + metrics::Metrics::addTagsToMetricName(name, tags); + auto& currentValue = _counters[metricName]; + currentValue = currentValue + delta; + } + + void recordTimer(const std::string& name, + int64_t time, + const metrics::StatsReporter::TagMap& tags) override + { + } + + void updateGauge(const std::string& name, + int64_t time, + const metrics::StatsReporter::TagMap& tags) override + { + } + + int64_t counterValue(const std::string& name, + const metrics::StatsReporter::TagMap& tags) const + { + std::lock_guard<std::mutex> lock(_mutex); + + const auto metricName = + metrics::Metrics::addTagsToMetricName(name, tags); + return _counters[metricName]; + } + + private: + mutable ValueMap _counters; + mutable std::mutex _mutex; +}; + +constexpr auto kDefaultMaxValueLength = 8; + +class TestRestrictionManager : public RestrictionManager { + public: + ~TestRestrictionManager() { close(); } + + Restriction getRestriction(const std::string&, + const std::string& key) override + { + const auto keyAllowed = (!key.empty() && key[0] == 'a'); + return Restriction(keyAllowed, kDefaultMaxValueLength); + } +}; + +template <typename FieldIterator> +void log(FieldIterator, FieldIterator) +{ +} + +} // anonymous namespace + +TEST(Baggage, restrictionManagerTest) +{ + auto logFn = &log<std::vector<Tag>::const_iterator>; + TestRestrictionManager manager; + auto metrics = metrics::Metrics::makeNullMetrics(); + BaggageSetter setter(manager, *metrics); + Span span( + nullptr, + SpanContext(TraceID(), + 123, + 456, + static_cast<unsigned char>(SpanContext::Flag::kSampled), + SpanContext::StrMap())); + auto baggage = span.context().baggage(); + setter.setBaggage(span, baggage, "abc", "123", logFn); + ASSERT_EQ(1, baggage.size()); + ASSERT_EQ("123", baggage["abc"]); + setter.setBaggage(span, baggage, "bcd", "234", logFn); + ASSERT_EQ(1, baggage.size()); + setter.setBaggage(span, baggage, "abc", "1234567890", logFn); + ASSERT_EQ("12345678", baggage["abc"]); +} + +TEST(Baggage, testRemoteRestrictionManagerDefaults) +{ + auto logger = logging::nullLogger(); + auto metrics = metrics::Metrics::makeNullMetrics(); + RemoteRestrictionManager manager( + "test-service", + "", + false, + RemoteRestrictionManager::Clock::duration(), + *logger, + *metrics); + ASSERT_EQ(RemoteRestrictionManager::defaultRefreshInterval(), + manager.refreshInterval()); + ASSERT_EQ( + Restriction(true, RemoteRestrictionManager::kDefaultMaxValueLength), + manager.getRestriction("test-service", "abc")); +} + +TEST(Baggage, testRemoteRestrictionManagerFunctionality) +{ + auto logger = logging::consoleLogger(); + + TestStatsReporter testReporter; + auto metrics = metrics::Metrics::fromStatsReporter(testReporter); + + auto mockAgent = testutils::MockAgent::make(); + mockAgent->start(); + RemoteRestrictionManager manager( + "test-service", + mockAgent->samplingServerAddress().authority(), + true, + std::chrono::milliseconds(100), + *logger, + *metrics); + ASSERT_EQ(Restriction(false, 0), + manager.getRestriction("test-service", "abc")); + mockAgent->addBaggageRestriction("abc", Restriction(true, 1)); + + // Wait for the Update Restrictions to occur + // This is done by listening to the number of update published via the Metrics + // Typically, On Windows with Debug mode, the update happens after 700ms + for (int sleepIndex = 0; sleepIndex < 100; ++sleepIndex) { + auto counterVal = testReporter.counterValue( + "jaeger.baggage-restrictions-update", { { "result", "ok" } }); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + if (counterVal > 0) { + break; + } + } + + ASSERT_EQ(Restriction(true, 1), + manager.getRestriction("test-service", "abc")); + ASSERT_EQ(Restriction(false, 0), + manager.getRestriction("test-service", "bcd")); + manager.close(); +} + +} // namespace baggage +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionJSON.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionJSON.cpp new file mode 100644 index 000000000..b4e387efd --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionJSON.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/baggage/RemoteRestrictionJSON.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionJSON.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionJSON.h new file mode 100644 index 000000000..a1772d977 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionJSON.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_BAGGAGE_REMOTERESTRICTIONJSON_H +#define JAEGERTRACING_BAGGAGE_REMOTERESTRICTIONJSON_H + +#include <cstdint> +#include <nlohmann/json.hpp> +#include <string> +#include <vector> + +#include "jaegertracing/Compilers.h" +#include "jaegertracing/thrift-gen/BaggageRestrictionManager.h" +#include "jaegertracing/thrift-gen/baggage_types.h" + +namespace jaegertracing { +namespace thrift { + +inline void to_json(nlohmann::json& json, const BaggageRestriction& restriction) +{ + json["baggageKey"] = restriction.baggageKey; + json["maxValueLength"] = restriction.maxValueLength; +} + +inline void from_json(const nlohmann::json& json, + BaggageRestriction& restriction) +{ + restriction.__set_baggageKey(json.at("baggageKey")); + restriction.__set_maxValueLength(json.at("maxValueLength")); +} + +using BaggageRestrictionList = + BaggageRestrictionManager_getBaggageRestrictions_result; + +inline void to_json(nlohmann::json& json, const BaggageRestrictionList& list) +{ + json = list.success; +} + +inline void from_json(const nlohmann::json& json, BaggageRestrictionList& list) +{ + list.success = json.get<std::vector<BaggageRestriction>>(); + list.__isset.success = true; +} + +} // namespace thrift +} // namespace jaegertracing + +#endif // JAEGERTRACING_BAGGAGE_REMOTERESTRICTIONJSON_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionManager.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionManager.cpp new file mode 100644 index 000000000..39024adcb --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionManager.cpp @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/baggage/RemoteRestrictionManager.h" + +#include <sstream> + +#include "jaegertracing/baggage/RemoteRestrictionJSON.h" +#include "jaegertracing/net/http/Response.h" +#include "jaegertracing/utils/ErrorUtil.h" + +namespace jaegertracing { +namespace baggage { +namespace { + +constexpr auto kDefaultHostPort = "127.0.0.1:5778"; + +} // anonymous namespace + +RemoteRestrictionManager::RemoteRestrictionManager( + const std::string& serviceName, + const std::string& hostPort, + bool denyBaggageOnInitializationFailure, + const Clock::duration& refreshInterval, + logging::Logger& logger, + metrics::Metrics& metrics) + : _serviceName(serviceName) + , _serverAddress( + net::IPAddress::v4(hostPort.empty() ? kDefaultHostPort : hostPort)) + , _denyBaggageOnInitializationFailure(denyBaggageOnInitializationFailure) + , _refreshInterval(refreshInterval == Clock::duration() + ? defaultRefreshInterval() + : refreshInterval) + , _logger(logger) + , _metrics(metrics) + , _running(true) + , _initialized(false) + , _thread([this]() { poll(); }) +{ +} + +Restriction +RemoteRestrictionManager::getRestriction(const std::string& /* service */, + const std::string& key) +{ + std::lock_guard<std::mutex> lock(_mutex); + + if (!_initialized) { + if (_denyBaggageOnInitializationFailure) { + return Restriction(false, 0); + } + return Restriction(true, kDefaultMaxValueLength); + } + + auto itr = _restrictions.find(key); + if (itr != std::end(_restrictions)) { + return itr->second; + } + return Restriction(false, 0); +} + +void RemoteRestrictionManager::close() noexcept +{ + std::unique_lock<std::mutex> lock(_mutex); + if (!_running) { + return; + } + _running = false; + lock.unlock(); + _cv.notify_one(); + _thread.join(); +} + +void RemoteRestrictionManager::poll() noexcept +{ + net::URI remoteURI; + try { + std::ostringstream oss; + oss << "http://" << _serverAddress.authority() + << "/baggageRestrictions?service=" + << net::URI::queryEscape(_serviceName); + remoteURI = net::URI::parse(oss.str()); + updateRestrictions(remoteURI); + } catch (...) { + auto logger = logging::consoleLogger(); + utils::ErrorUtil::logError(*logger, + "Failed in RemoteRestrictionManager::poll"); + return; + } + + Clock::time_point lastUpdateTime = Clock::now(); + while (true) { + { + std::unique_lock<std::mutex> lock(_mutex); + _cv.wait_until(lock, lastUpdateTime + _refreshInterval, [this]() { + return !_running; + }); + if (!_running) { + return; + } + } + + if ((Clock::now() - lastUpdateTime) >= _refreshInterval) { + updateRestrictions(remoteURI); + lastUpdateTime = Clock::now(); + } + } +} + +void RemoteRestrictionManager::updateRestrictions( + const net::URI& remoteURI) noexcept +{ + try { + const auto responseHTTP = net::http::get(remoteURI); + if (responseHTTP.statusCode() != 200) { + std::ostringstream oss; + oss << "Received HTTP error response" + << ", uri=" << remoteURI + << ", statusCode=" << responseHTTP.statusCode() + << ", reason=" << responseHTTP.reason(); + _logger.error(oss.str()); + return; + } + + thrift::BaggageRestrictionManager_getBaggageRestrictions_result + response = nlohmann::json::parse(responseHTTP.body()); + if (response.__isset.success) { + KeyRestrictionMap restrictions; + restrictions.reserve(response.success.size()); + std::transform( + std::begin(response.success), + std::end(response.success), + std::inserter(restrictions, std::end(restrictions)), + [](const thrift::BaggageRestriction restriction) { + return std::make_pair( + restriction.baggageKey, + Restriction(true, restriction.maxValueLength)); + }); + { + std::lock_guard<std::mutex> lock(_mutex); + _restrictions = std::move(restrictions); + if (!_initialized) { + _initialized = true; + } + } + _metrics.baggageRestrictionsUpdateSuccess().inc(1); + } + else { + std::ostringstream oss; + oss << "Failed to update baggage restrictions" + ", response=" + << responseHTTP.body(); + _logger.error(oss.str()); + _metrics.baggageRestrictionsUpdateFailure().inc(1); + } + } catch (...) { + utils::ErrorUtil::logError(_logger, + "Failed to update baggage restrictions"); + _metrics.baggageRestrictionsUpdateFailure().inc(1); + } +} + +} // namespace baggage +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionManager.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionManager.h new file mode 100644 index 000000000..a0d44ac49 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RemoteRestrictionManager.h @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_BAGGAGE_REMOTERESTRICTIONMANAGER_H +#define JAEGERTRACING_BAGGAGE_REMOTERESTRICTIONMANAGER_H + +#include <chrono> +#include <condition_variable> +#include <mutex> +#include <string> +#include <thread> +#include <unordered_map> + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/Logging.h" +#include "jaegertracing/baggage/Restriction.h" +#include "jaegertracing/baggage/RestrictionManager.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/net/URI.h" +#include "jaegertracing/thrift-gen/BaggageRestrictionManager.h" + +namespace jaegertracing { +namespace baggage { + +class RemoteRestrictionManager : public RestrictionManager { + public: + using Clock = std::chrono::steady_clock; + using KeyRestrictionMap = std::unordered_map<std::string, Restriction>; + + static constexpr auto kDefaultDenyBaggageOnInitializationFailure = false; + static constexpr auto kDefaultMaxValueLength = + DefaultRestrictionManager::kDefaultMaxValueLength; + + static Clock::duration defaultRefreshInterval() + { + return std::chrono::minutes(1); + } + + RemoteRestrictionManager(const std::string& serviceName, + const std::string& hostPort, + bool denyBaggageOnInitializationFailure, + const Clock::duration& refreshInterval, + logging::Logger& logger, + metrics::Metrics& metrics); + + ~RemoteRestrictionManager() { close(); } + + Restriction getRestriction(const std::string& /* service */, + const std::string& key) override; + + void close() noexcept override; + + const Clock::duration& refreshInterval() const { return _refreshInterval; } + + private: + void poll() noexcept; + + void updateRestrictions(const net::URI& remoteURI) noexcept; + + std::string _serviceName; + net::IPAddress _serverAddress; + bool _denyBaggageOnInitializationFailure; + Clock::duration _refreshInterval; + logging::Logger& _logger; + metrics::Metrics& _metrics; + KeyRestrictionMap _restrictions; + bool _running; + bool _initialized; + std::thread _thread; + std::condition_variable _cv; + std::mutex _mutex; +}; + +} // namespace baggage +} // namespace jaegertracing + +#endif // JAEGERTRACING_BAGGAGE_REMOTERESTRICTIONMANAGER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/Restriction.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/Restriction.cpp new file mode 100644 index 000000000..1715171b3 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/Restriction.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/baggage/Restriction.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/Restriction.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/Restriction.h new file mode 100644 index 000000000..502c85004 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/Restriction.h @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_BAGGAGE_RESTRICTION_H +#define JAEGERTRACING_BAGGAGE_RESTRICTION_H + +namespace jaegertracing { +namespace baggage { + +class Restriction { + public: + Restriction(bool keyAllowed, int maxValueLength) + : _keyAllowed(keyAllowed) + , _maxValueLength(maxValueLength) + { + } + + friend bool operator==(const Restriction& lhs, const Restriction& rhs) + { + return lhs._keyAllowed == rhs._keyAllowed && + lhs._maxValueLength == rhs._maxValueLength; + } + + bool keyAllowed() const { return _keyAllowed; } + + int maxValueLength() const { return _maxValueLength; } + + private: + bool _keyAllowed; + int _maxValueLength; +}; + +} // namespace baggage +} // namespace jaegertracing + +#endif // JAEGERTRACING_BAGGAGE_RESTRICTION_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionManager.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionManager.cpp new file mode 100644 index 000000000..21a10eebf --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionManager.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/baggage/RestrictionManager.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionManager.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionManager.h new file mode 100644 index 000000000..37d5e67d9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionManager.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_BAGGAGE_RESTRICTIONMANAGER_H +#define JAEGERTRACING_BAGGAGE_RESTRICTIONMANAGER_H + +#include <string> + +#include "jaegertracing/baggage/Restriction.h" + +namespace jaegertracing { +namespace baggage { + +class RestrictionManager { + public: + virtual ~RestrictionManager() = default; + + virtual Restriction getRestriction(const std::string& service, + const std::string& key) = 0; + + virtual void close() noexcept {} +}; + +class DefaultRestrictionManager : public RestrictionManager { + public: + static constexpr auto kDefaultMaxValueLength = 2048; + + explicit DefaultRestrictionManager(int maxValueLength) + : _defaultRestriction(true, + maxValueLength == 0 ? kDefaultMaxValueLength + : maxValueLength) + { + } + + Restriction getRestriction(const std::string& service, + const std::string& key) override + { + return _defaultRestriction; + } + + private: + Restriction _defaultRestriction; +}; + +} // namespace baggage +} // namespace jaegertracing + +#endif // JAEGERTRACING_BAGGAGE_RESTRICTIONMANAGER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionsConfig.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionsConfig.cpp new file mode 100644 index 000000000..b44aa1181 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionsConfig.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/baggage/RestrictionsConfig.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionsConfig.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionsConfig.h new file mode 100644 index 000000000..6fe2f673d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/baggage/RestrictionsConfig.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_BAGGAGE_RESTRICTIONSCONFIG_H +#define JAEGERTRACING_BAGGAGE_RESTRICTIONSCONFIG_H + +#include "jaegertracing/Constants.h" +#include "jaegertracing/utils/YAML.h" +#include <chrono> +#include <string> + +namespace jaegertracing { +namespace baggage { + +class RestrictionsConfig { + public: + using Clock = std::chrono::steady_clock; + +#ifdef JAEGERTRACING_WITH_YAML_CPP + + static RestrictionsConfig parse(const YAML::Node& configYAML) + { + if (!configYAML.IsDefined() || !configYAML.IsMap()) { + return RestrictionsConfig(); + } + + const auto denyBaggageOnInitializationFailure = + utils::yaml::findOrDefault<bool>( + configYAML, "denyBaggageOnInitializationFailure", false); + const auto hostPort = + utils::yaml::findOrDefault<std::string>(configYAML, "hostPort", ""); + const auto refreshInterval = std::chrono::seconds( + utils::yaml::findOrDefault<int>(configYAML, "refreshInterval", 0)); + return RestrictionsConfig( + denyBaggageOnInitializationFailure, hostPort, refreshInterval); + } + +#endif // JAEGERTRACING_WITH_YAML_CPP + + explicit RestrictionsConfig( + bool denyBaggageOnInitializationFailure = false, + const std::string& hostPort = "", + const Clock::duration& refreshInterval = Clock::duration()) + : _denyBaggageOnInitializationFailure( + denyBaggageOnInitializationFailure) + , _hostPort(hostPort) + , _refreshInterval(refreshInterval) + { + } + + bool denyBaggageOnInitializationFailure() const + { + return _denyBaggageOnInitializationFailure; + } + + const std::string& hostPort() const { return _hostPort; } + + const Clock::duration& refreshInterval() const { return _refreshInterval; } + + private: + bool _denyBaggageOnInitializationFailure; + std::string _hostPort; + Clock::duration _refreshInterval; +}; + +} // namespace baggage +} // namespace jaegertracing + +#endif // JAEGERTRACING_BAGGAGE_RESTRICTIONSCONFIG_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Counter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Counter.cpp new file mode 100644 index 000000000..b26deba40 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Counter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/Counter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Counter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Counter.h new file mode 100644 index 000000000..8dff981c9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Counter.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_COUNTER_H +#define JAEGERTRACING_METRICS_COUNTER_H + +#include "jaegertracing/Compilers.h" + +#include <stdint.h> + +namespace jaegertracing { +namespace metrics { + +class Counter { + public: + virtual ~Counter() = default; + + virtual void inc(int64_t delta) = 0; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_COUNTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Gauge.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Gauge.cpp new file mode 100644 index 000000000..4b10a6f12 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Gauge.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/Gauge.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Gauge.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Gauge.h new file mode 100644 index 000000000..fdc9718a0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Gauge.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_GAUGE_H +#define JAEGERTRACING_METRICS_GAUGE_H + +#include "jaegertracing/Compilers.h" + +#include <stdint.h> + +namespace jaegertracing { +namespace metrics { + +class Gauge { + public: + virtual ~Gauge() = default; + + virtual void update(int64_t amount) = 0; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_GAUGE_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/InMemoryStatsReporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/InMemoryStatsReporter.cpp new file mode 100644 index 000000000..a438f115e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/InMemoryStatsReporter.cpp @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/InMemoryStatsReporter.h" + +#include "jaegertracing/metrics/Counter.h" +#include "jaegertracing/metrics/Gauge.h" +#include "jaegertracing/metrics/Metric.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/metrics/Timer.h" + +namespace jaegertracing { +namespace metrics { +namespace { + +template <typename Function> +void updateMap(InMemoryStatsReporter::ValueMap& map, + const std::string& name, + int64_t newValue, + const std::unordered_map<std::string, std::string>& tags, + Function f) +{ + const auto metricName = Metrics::addTagsToMetricName(name, tags); + auto& initialValue = map[metricName]; + initialValue = f(initialValue, newValue); +} + +} // anonymous namespace + +void InMemoryStatsReporter::incCounter( + const std::string& name, + int64_t delta, + const std::unordered_map<std::string, std::string>& tags) +{ + updateMap(_counters, + name, + delta, + tags, + [](int64_t initialValue, int64_t newValue) { + return initialValue + newValue; + }); +} + +void InMemoryStatsReporter::recordTimer( + const std::string& name, + int64_t time, + const std::unordered_map<std::string, std::string>& tags) +{ + updateMap( + _timers, name, time, tags, [](int64_t initialValue, int64_t newValue) { + return initialValue + newValue; + }); +} + +void InMemoryStatsReporter::updateGauge( + const std::string& name, + int64_t amount, + const std::unordered_map<std::string, std::string>& tags) +{ + updateMap(_gauges, name, amount, tags, [](int64_t, int64_t newValue) { + return newValue; + }); +} + +void InMemoryStatsReporter::reset() +{ + _counters.clear(); + _gauges.clear(); + _timers.clear(); +} + +} // namespace metrics +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/InMemoryStatsReporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/InMemoryStatsReporter.h new file mode 100644 index 000000000..98e8e39c1 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/InMemoryStatsReporter.h @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_INMEMORYSTATSREPORTER_H +#define JAEGERTRACING_METRICS_INMEMORYSTATSREPORTER_H + +#include "jaegertracing/metrics/StatsReporter.h" +#include <cstdint> +#include <string> +#include <unordered_map> + +namespace jaegertracing { +namespace metrics { + +class InMemoryStatsReporter : public StatsReporter { + public: + using ValueMap = std::unordered_map<std::string, int64_t>; + + using StatsReporter::incCounter; + using StatsReporter::recordTimer; + using StatsReporter::updateGauge; + + virtual ~InMemoryStatsReporter() = default; + + void incCounter(const std::string& name, + int64_t delta, + const TagMap& tags) override; + + void recordTimer(const std::string& name, + int64_t time, + const TagMap& tags) override; + + void updateGauge(const std::string& name, + int64_t time, + const TagMap& tags) override; + + void reset(); + + const ValueMap& counters() const { return _counters; } + + const ValueMap& gauges() const { return _gauges; } + + const ValueMap& timers() const { return _timers; } + + private: + ValueMap _counters; + ValueMap _gauges; + ValueMap _timers; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_INMEMORYSTATSREPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metric.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metric.cpp new file mode 100644 index 000000000..34c625777 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metric.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/Metric.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metric.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metric.h new file mode 100644 index 000000000..efdbb4b43 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metric.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_METRIC_H +#define JAEGERTRACING_METRICS_METRIC_H + +#include <string> +#include <unordered_map> + +#include "jaegertracing/Compilers.h" + +namespace jaegertracing { +namespace metrics { + +class Metric { + public: + using TagMap = std::unordered_map<std::string, std::string>; + + Metric(const std::string& name, const TagMap& tags) + : _name(name) + , _tags(tags) + { + } + + virtual ~Metric() = default; + + const std::string& name() const { return _name; } + + const TagMap& tags() const { return _tags; } + + protected: + std::string& name() { return _name; } + + TagMap& tags() { return _tags; } + + private: + std::string _name; + TagMap _tags; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_METRIC_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metrics.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metrics.cpp new file mode 100644 index 000000000..57c5c2a46 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metrics.cpp @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/metrics/Counter.h" +#include "jaegertracing/metrics/Gauge.h" +#include "jaegertracing/metrics/NullStatsFactory.h" +#include <iterator> +#include <map> +#include <sstream> +#include <utility> + +namespace jaegertracing { +namespace metrics { + +std::unique_ptr<Metrics> Metrics::makeNullMetrics() +{ + metrics::NullStatsFactory factory; + return std::unique_ptr<Metrics>(new Metrics(factory)); +} + +std::string Metrics::addTagsToMetricName( + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) +{ + std::ostringstream buffer; + buffer << name; + const std::map<std::string, std::string> orderedMap(std::begin(tags), + std::end(tags)); + for (auto&& pair : orderedMap) { + buffer << '.' << pair.first << '=' << pair.second; + } + return buffer.str(); +} + +Metrics::~Metrics() = default; + +} // namespace metrics +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metrics.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metrics.h new file mode 100644 index 000000000..5c12d052d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Metrics.h @@ -0,0 +1,243 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_METRICS_H +#define JAEGERTRACING_METRICS_METRICS_H + +#include <string> +#include <unordered_map> + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/metrics/Counter.h" +#include "jaegertracing/metrics/Gauge.h" +#include "jaegertracing/metrics/StatsFactory.h" +#include "jaegertracing/metrics/StatsFactoryImpl.h" +#include "jaegertracing/metrics/StatsReporter.h" + +namespace jaegertracing { +namespace metrics { + +class Metrics { + public: + static std::unique_ptr<Metrics> makeNullMetrics(); + + static std::unique_ptr<Metrics> fromStatsReporter(StatsReporter& reporter) + { + // Factory only used for constructor, so need not live past the + // initialization of Metrics object. + StatsFactoryImpl factory(reporter); + return std::unique_ptr<Metrics>(new Metrics(factory)); + } + + static std::string addTagsToMetricName( + const std::string& name, + const std::unordered_map<std::string, std::string>& tags); + + explicit Metrics(StatsFactory& factory) + : _tracesStartedSampled(factory.createCounter( + "jaeger.traces", { { "state", "started" }, { "sampled", "y" } })) + , _tracesStartedNotSampled(factory.createCounter( + "jaeger.traces", { { "state", "started" }, { "sampled", "n" } })) + , _spansStarted(factory.createCounter( + "jaeger.spans", + { { "state", "started" }, { "group", "lifecycle" } })) + , _spansFinished(factory.createCounter( + "jaeger.spans", + { { "state", "finished" }, { "group", "lifecycle" } })) + , _spansSampled(factory.createCounter( + "jaeger.spans", { { "group", "sampling" }, { "sampled", "y" } })) + , _spansNotSampled(factory.createCounter( + "jaeger.spans", { { "group", "sampling" }, { "sampled", "n" } })) + , _decodingErrors(factory.createCounter("jaeger.decoding-errors")) + , _reporterSuccess(factory.createCounter("jaeger.reporter-spans", + { { "state", "success" } })) + , _reporterFailure(factory.createCounter("jaeger.reporter-spans", + { { "state", "failure" } })) + , _reporterDropped(factory.createCounter("jaeger.reporter-spans", + { { "state", "dropped" } })) + , _reporterQueueLength(factory.createGauge("jaeger.reporter-queue")) + , _samplerRetrieved(factory.createCounter("jaeger.sampler", + { { "state", "retrieved" } })) + , _samplerUpdated(factory.createCounter("jaeger.sampler", + { { "state", "updated" } })) + , _samplerUpdateFailure(factory.createCounter( + "jaeger.sampler", + { { "state", "failure" }, { "phase", "updating" } })) + , _samplerQueryFailure(factory.createCounter( + "jaeger.sampler", + { { "state", "failure" }, { "phase", "query" } })) + , _samplerParsingFailure(factory.createCounter( + "jaeger.sampler", + { { "state", "failure" }, { "phase", "parsing" } })) + , _baggageUpdateSuccess(factory.createCounter("jaeger.baggage-update", + { { "result", "ok" } })) + , _baggageUpdateFailure(factory.createCounter("jaeger.baggage-update", + { { "result", "err" } })) + , _baggageTruncate(factory.createCounter("jaeger.baggage-truncate")) + , _baggageRestrictionsUpdateSuccess(factory.createCounter( + "jaeger.baggage-restrictions-update", { { "result", "ok" } })) + , _baggageRestrictionsUpdateFailure(factory.createCounter( + "jaeger.baggage-restrictions-update", { { "result", "err" } })) + { + } + + ~Metrics(); + + const Counter& tracesStartedSampled() const + { + return *_tracesStartedSampled; + } + + Counter& tracesStartedSampled() { return *_tracesStartedSampled; } + + const Counter& tracesStartedNotSampled() const + { + return *_tracesStartedNotSampled; + } + + Counter& tracesStartedNotSampled() { return *_tracesStartedNotSampled; } + + const Counter& spansStarted() const { return *_spansStarted; } + + Counter& spansStarted() { return *_spansStarted; } + + const Counter& spansFinished() const { return *_spansFinished; } + + Counter& spansFinished() { return *_spansFinished; } + + const Counter& spansSampled() const { return *_spansSampled; } + + Counter& spansSampled() { return *_spansSampled; } + + const Counter& spansNotSampled() const { return *_spansNotSampled; } + + Counter& spansNotSampled() { return *_spansNotSampled; } + + const Counter& decodingErrors() const { return *_decodingErrors; } + + Counter& decodingErrors() { return *_decodingErrors; } + + const Counter& reporterSuccess() const { return *_reporterSuccess; } + + Counter& reporterSuccess() { return *_reporterSuccess; } + + const Counter& reporterFailure() const { return *_reporterFailure; } + + Counter& reporterFailure() { return *_reporterFailure; } + + const Counter& reporterDropped() const { return *_reporterDropped; } + + Counter& reporterDropped() { return *_reporterDropped; } + + const Gauge& reporterQueueLength() const { return *_reporterQueueLength; } + + Gauge& reporterQueueLength() { return *_reporterQueueLength; } + + const Counter& samplerRetrieved() const { return *_samplerRetrieved; } + + Counter& samplerRetrieved() { return *_samplerRetrieved; } + + const Counter& samplerUpdated() const { return *_samplerUpdated; } + + Counter& samplerUpdated() { return *_samplerUpdated; } + + const Counter& samplerUpdateFailure() const + { + return *_samplerUpdateFailure; + } + + Counter& samplerUpdateFailure() { return *_samplerUpdateFailure; } + + const Counter& samplerQueryFailure() const { return *_samplerQueryFailure; } + + Counter& samplerQueryFailure() { return *_samplerQueryFailure; } + + const Counter& samplerParsingFailure() const + { + return *_samplerParsingFailure; + } + + Counter& samplerParsingFailure() { return *_samplerParsingFailure; } + + const Counter& baggageUpdateSuccess() const + { + return *_baggageUpdateSuccess; + } + + Counter& baggageUpdateSuccess() { return *_baggageUpdateSuccess; } + + const Counter& baggageUpdateFailure() const + { + return *_baggageUpdateFailure; + } + + Counter& baggageUpdateFailure() { return *_baggageUpdateFailure; } + + const Counter& baggageTruncate() const { return *_baggageTruncate; } + + Counter& baggageTruncate() { return *_baggageTruncate; } + + const Counter& baggageRestrictionsUpdateSuccess() const + { + return *_baggageRestrictionsUpdateSuccess; + } + + Counter& baggageRestrictionsUpdateSuccess() + { + return *_baggageRestrictionsUpdateSuccess; + } + + const Counter& baggageRestrictionsUpdateFailure() const + { + return *_baggageRestrictionsUpdateFailure; + } + + Counter& baggageRestrictionsUpdateFailure() + { + return *_baggageRestrictionsUpdateFailure; + } + + private: + std::unique_ptr<Counter> _tracesStartedSampled; + std::unique_ptr<Counter> _tracesStartedNotSampled; + std::unique_ptr<Counter> _tracesJoinedSampled; + std::unique_ptr<Counter> _tracesJoinedNotSampled; + std::unique_ptr<Counter> _spansStarted; + std::unique_ptr<Counter> _spansFinished; + std::unique_ptr<Counter> _spansSampled; + std::unique_ptr<Counter> _spansNotSampled; + std::unique_ptr<Counter> _decodingErrors; + std::unique_ptr<Counter> _reporterSuccess; + std::unique_ptr<Counter> _reporterFailure; + std::unique_ptr<Counter> _reporterDropped; + std::unique_ptr<Gauge> _reporterQueueLength; + std::unique_ptr<Counter> _samplerRetrieved; + std::unique_ptr<Counter> _samplerUpdated; + std::unique_ptr<Counter> _samplerUpdateFailure; + std::unique_ptr<Counter> _samplerQueryFailure; + std::unique_ptr<Counter> _samplerParsingFailure; + std::unique_ptr<Counter> _baggageUpdateSuccess; + std::unique_ptr<Counter> _baggageUpdateFailure; + std::unique_ptr<Counter> _baggageTruncate; + std::unique_ptr<Counter> _baggageRestrictionsUpdateSuccess; + std::unique_ptr<Counter> _baggageRestrictionsUpdateFailure; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_METRICS_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/MetricsTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/MetricsTest.cpp new file mode 100644 index 000000000..f9c7eeb27 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/MetricsTest.cpp @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/Counter.h" +#include "jaegertracing/metrics/Gauge.h" +#include "jaegertracing/metrics/InMemoryStatsReporter.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/metrics/StatsFactoryImpl.h" +#include "jaegertracing/metrics/Timer.h" +#include <cstdint> +#include <gtest/gtest.h> +#include <iterator> +#include <memory> +#include <unordered_map> +#include <utility> + +namespace jaegertracing { +namespace metrics { + +class MetricsTest : public ::testing::Test { + public: + MetricsTest() + : _metricsReporter() + , _metrics(Metrics::fromStatsReporter(_metricsReporter)) + { + } + + protected: + InMemoryStatsReporter _metricsReporter; + std::unique_ptr<Metrics> _metrics; +}; + +TEST_F(MetricsTest, testCounter) +{ + constexpr auto counterValue = static_cast<int64_t>(3); + constexpr auto metricName = "jaeger.test-counter"; + StatsFactoryImpl factory(_metricsReporter); + auto counter = factory.createCounter(metricName); + counter->inc(counterValue); + const auto& counters = _metricsReporter.counters(); + ASSERT_EQ(1, counters.size()); + auto itr = counters.find(metricName); + ASSERT_TRUE(itr != std::end(counters)); + ASSERT_EQ(counterValue, itr->second); +} + +TEST_F(MetricsTest, testGauge) +{ + constexpr auto gaugeValue = static_cast<int64_t>(3); + constexpr auto metricName = "jaeger.test-gauge"; + StatsFactoryImpl factory(_metricsReporter); + auto gauge = factory.createGauge(metricName); + gauge->update(gaugeValue); + const auto& gauges = _metricsReporter.gauges(); + ASSERT_EQ(1, gauges.size()); + auto itr = gauges.find(metricName); + ASSERT_TRUE(itr != std::end(gauges)); + ASSERT_EQ(gaugeValue, itr->second); +} + +TEST_F(MetricsTest, testTimer) +{ + constexpr auto timeValue = static_cast<int64_t>(5); + constexpr auto metricName = "jaeger.test-timer"; + StatsFactoryImpl factory(_metricsReporter); + auto timer = factory.createTimer(metricName); + timer->record(timeValue); + const auto& timers = _metricsReporter.timers(); + ASSERT_EQ(1, timers.size()); + auto itr = timers.find(metricName); + ASSERT_TRUE(itr != std::end(timers)); + ASSERT_EQ(timeValue, itr->second); +} + +TEST_F(MetricsTest, testReset) +{ + _metrics->tracesStartedSampled().inc(1); + const auto& counters = _metricsReporter.counters(); + ASSERT_EQ(1, counters.size()); + + _metrics->reporterQueueLength().update(1); + const auto& gauges = _metricsReporter.gauges(); + ASSERT_EQ(1, gauges.size()); + + constexpr auto time = static_cast<int64_t>(1); + constexpr auto timerName = "jaeger.test-timer"; + _metricsReporter.recordTimer(timerName, time); + const auto& timers = _metricsReporter.timers(); + ASSERT_EQ(1, timers.size()); + + _metricsReporter.reset(); + ASSERT_TRUE(counters.empty()); + ASSERT_TRUE(gauges.empty()); + ASSERT_TRUE(timers.empty()); +} + +} // namespace metrics +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullCounter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullCounter.cpp new file mode 100644 index 000000000..3cb68d156 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullCounter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/NullCounter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullCounter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullCounter.h new file mode 100644 index 000000000..a9fc055c7 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullCounter.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_NULLCOUNTER_H +#define JAEGERTRACING_METRICS_NULLCOUNTER_H + +#include "jaegertracing/metrics/Counter.h" +#include <cstdint> + +namespace jaegertracing { +namespace metrics { + +class NullCounter : public Counter { + public: + void inc(int64_t) override {} +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_NULLCOUNTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullGauge.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullGauge.cpp new file mode 100644 index 000000000..a4c7426ce --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullGauge.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/NullGauge.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullGauge.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullGauge.h new file mode 100644 index 000000000..22810ced5 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullGauge.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_NULLGAUGE_H +#define JAEGERTRACING_METRICS_NULLGAUGE_H + +#include "jaegertracing/metrics/Gauge.h" +#include <cstdint> + +namespace jaegertracing { +namespace metrics { + +class NullGauge : public Gauge { + public: + void update(int64_t) override {} +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_NULLGAUGE_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactory.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactory.cpp new file mode 100644 index 000000000..ed1a77466 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactory.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/NullStatsFactory.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactory.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactory.h new file mode 100644 index 000000000..5449587ef --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactory.h @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_NULLSTATSFACTORY_H +#define JAEGERTRACING_METRICS_NULLSTATSFACTORY_H + +#include <memory> +#include <string> +#include <unordered_map> + +#include "jaegertracing/metrics/NullCounter.h" +#include "jaegertracing/metrics/NullGauge.h" +#include "jaegertracing/metrics/NullTimer.h" +#include "jaegertracing/metrics/StatsFactory.h" + +namespace jaegertracing { +namespace metrics { + +class Counter; +class Gauge; +class Timer; + +class NullStatsFactory : public StatsFactory { + public: + using StatsFactory::createCounter; + using StatsFactory::createGauge; + using StatsFactory::createTimer; + + std::unique_ptr<Counter> + createCounter(const std::string&, + const std::unordered_map<std::string, std::string>&) override + { + return std::unique_ptr<Counter>(new NullCounter()); + } + + std::unique_ptr<Timer> + createTimer(const std::string&, + const std::unordered_map<std::string, std::string>&) override + { + return std::unique_ptr<Timer>(new NullTimer()); + } + + std::unique_ptr<Gauge> + createGauge(const std::string&, + const std::unordered_map<std::string, std::string>&) override + { + return std::unique_ptr<Gauge>(new NullGauge()); + } +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_NULLSTATSFACTORY_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactoryTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactoryTest.cpp new file mode 100644 index 000000000..e1afea3b4 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsFactoryTest.cpp @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/Counter.h" +#include "jaegertracing/metrics/Gauge.h" +#include "jaegertracing/metrics/NullStatsFactory.h" +#include "jaegertracing/metrics/Timer.h" +#include <gtest/gtest.h> +#include <memory> + +namespace jaegertracing { +namespace metrics { + +TEST(NullStatsFactory, test) +{ + NullStatsFactory factory; + factory.createGauge("")->update(1); + factory.createTimer("")->record(1); + factory.createCounter("")->inc(1); +} + +} // namespace metrics +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsReporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsReporter.cpp new file mode 100644 index 000000000..bad6bafae --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsReporter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/NullStatsReporter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsReporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsReporter.h new file mode 100644 index 000000000..715ed7555 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullStatsReporter.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_NULLSTATSREPORTER_H +#define JAEGERTRACING_METRICS_NULLSTATSREPORTER_H + +#include "jaegertracing/metrics/StatsReporter.h" +#include <cstdint> +#include <string> +#include <unordered_map> + +namespace jaegertracing { +namespace metrics { + +class NullStatsReporter : public StatsReporter { + public: + using StatsReporter::incCounter; + using StatsReporter::recordTimer; + using StatsReporter::updateGauge; + + ~NullStatsReporter() = default; + + void + incCounter(const std::string&, + int64_t, + const std::unordered_map<std::string, std::string>&) override + { + } + + void + recordTimer(const std::string&, + int64_t, + const std::unordered_map<std::string, std::string>&) override + { + } + + void + updateGauge(const std::string&, + int64_t, + const std::unordered_map<std::string, std::string>&) override + { + } +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_NULLSTATSREPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullTimer.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullTimer.cpp new file mode 100644 index 000000000..3e596473d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullTimer.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/NullTimer.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullTimer.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullTimer.h new file mode 100644 index 000000000..c1979ea61 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/NullTimer.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_NULLTIMER_H +#define JAEGERTRACING_METRICS_NULLTIMER_H + +#include "jaegertracing/metrics/Timer.h" +#include <cstdint> + +namespace jaegertracing { +namespace metrics { + +class NullTimer : public Timer { + public: + void record(int64_t) override {} +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_NULLTIMER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactory.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactory.cpp new file mode 100644 index 000000000..def039690 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactory.cpp @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/StatsFactory.h" + +#include "jaegertracing/metrics/Counter.h" +#include "jaegertracing/metrics/Gauge.h" +#include "jaegertracing/metrics/Timer.h" + +namespace jaegertracing { +namespace metrics { + +std::unique_ptr<Counter> StatsFactory::createCounter(const std::string& name) +{ + return createCounter(name, TagMap()); +} + +std::unique_ptr<Timer> StatsFactory::createTimer(const std::string& name) +{ + return createTimer(name, TagMap()); +} + +std::unique_ptr<Gauge> StatsFactory::createGauge(const std::string& name) +{ + return createGauge(name, TagMap()); +} + +} // namespace metrics +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactory.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactory.h new file mode 100644 index 000000000..3dedb66f2 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactory.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_STATSFACTORY_H +#define JAEGERTRACING_METRICS_STATSFACTORY_H + +#include <memory> +#include <string> +#include <unordered_map> + +#include "jaegertracing/Compilers.h" + +namespace jaegertracing { +namespace metrics { + +class Counter; +class Gauge; +class Timer; + +class StatsFactory { + public: + using TagMap = std::unordered_map<std::string, std::string>; + + virtual ~StatsFactory() = default; + + std::unique_ptr<Counter> createCounter(const std::string& name); + + std::unique_ptr<Timer> createTimer(const std::string& name); + + std::unique_ptr<Gauge> createGauge(const std::string& name); + + virtual std::unique_ptr<Counter> createCounter(const std::string& name, + const TagMap& tags) = 0; + + virtual std::unique_ptr<Timer> createTimer(const std::string& name, + const TagMap& tags) = 0; + + virtual std::unique_ptr<Gauge> createGauge(const std::string& name, + const TagMap& tags) = 0; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_STATSFACTORY_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactoryImpl.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactoryImpl.cpp new file mode 100644 index 000000000..bbd8ec29b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactoryImpl.cpp @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/StatsFactoryImpl.h" +#include "jaegertracing/metrics/Counter.h" +#include "jaegertracing/metrics/Gauge.h" +#include "jaegertracing/metrics/Metric.h" +#include "jaegertracing/metrics/StatsReporter.h" +#include "jaegertracing/metrics/Timer.h" +#include <cstdint> + +namespace jaegertracing { +namespace metrics { +namespace { + +class ReportedMetric : public Metric { + public: + ReportedMetric(StatsReporter& reporter, + const std::string& name, + const TagMap& tags) + : Metric(name, tags) + , _reporter(reporter) + { + } + + virtual ~ReportedMetric() = default; + + protected: + StatsReporter& reporter() { return _reporter; } + + private: + StatsReporter& _reporter; +}; + +class CounterImpl : public ReportedMetric, public Counter { + public: + CounterImpl(StatsReporter& reporter, + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) + : ReportedMetric(reporter, name, tags) + { + } + + void inc(int64_t delta) override + { + reporter().incCounter(name(), delta, tags()); + } +}; + +class TimerImpl : public ReportedMetric, public Timer { + public: + TimerImpl(StatsReporter& reporter, + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) + : ReportedMetric(reporter, name, tags) + { + } + + void record(int64_t time) override + { + reporter().recordTimer(name(), time, tags()); + } +}; + +class GaugeImpl : public ReportedMetric, public Gauge { + public: + GaugeImpl(StatsReporter& reporter, + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) + : ReportedMetric(reporter, name, tags) + { + } + + void update(int64_t amount) override + { + reporter().updateGauge(name(), amount, tags()); + } +}; + +} // anonymous namespace + +StatsFactoryImpl::StatsFactoryImpl(StatsReporter& reporter) + : _reporter(reporter) +{ +} + +std::unique_ptr<Counter> StatsFactoryImpl::createCounter( + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) +{ + return std::unique_ptr<Counter>(new CounterImpl(_reporter, name, tags)); +} + +std::unique_ptr<Timer> StatsFactoryImpl::createTimer( + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) +{ + return std::unique_ptr<Timer>(new TimerImpl(_reporter, name, tags)); +} + +std::unique_ptr<Gauge> StatsFactoryImpl::createGauge( + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) +{ + return std::unique_ptr<Gauge>(new GaugeImpl(_reporter, name, tags)); +} + +} // namespace metrics +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactoryImpl.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactoryImpl.h new file mode 100644 index 000000000..28e090e38 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsFactoryImpl.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_STATSFACTORYIMPL_H +#define JAEGERTRACING_METRICS_STATSFACTORYIMPL_H + +#include <memory> +#include <string> +#include <unordered_map> + +#include "jaegertracing/metrics/StatsFactory.h" +#include "jaegertracing/metrics/StatsReporter.h" + +namespace jaegertracing { +namespace metrics { + +class Counter; +class Gauge; +class Timer; + +class StatsFactoryImpl : public StatsFactory { + public: + using StatsFactory::createCounter; + using StatsFactory::createGauge; + using StatsFactory::createTimer; + + explicit StatsFactoryImpl(StatsReporter& reporter); + + ~StatsFactoryImpl() = default; + + std::unique_ptr<Counter> createCounter( + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) override; + + std::unique_ptr<Timer> createTimer( + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) override; + + std::unique_ptr<Gauge> createGauge( + const std::string& name, + const std::unordered_map<std::string, std::string>& tags) override; + + private: + StatsReporter& _reporter; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_STATSFACTORYIMPL_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsReporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsReporter.cpp new file mode 100644 index 000000000..b11d641b7 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsReporter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/StatsReporter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsReporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsReporter.h new file mode 100644 index 000000000..960dd5091 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/StatsReporter.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_STATSREPORTER_H +#define JAEGERTRACING_METRICS_STATSREPORTER_H + +#include <cstdint> +#include <string> +#include <unordered_map> + +namespace jaegertracing { +namespace metrics { + +class StatsReporter { + public: + using TagMap = std::unordered_map<std::string, std::string>; + + virtual ~StatsReporter() = default; + + void incCounter(const std::string& name, int64_t delta) + { + incCounter(name, delta, TagMap()); + } + + void recordTimer(const std::string& name, int64_t delta) + { + recordTimer(name, delta, TagMap()); + } + + void updateGauge(const std::string& name, int64_t delta) + { + updateGauge(name, delta, TagMap()); + } + + virtual void + incCounter(const std::string& name, int64_t delta, const TagMap& tags) = 0; + + virtual void + recordTimer(const std::string& name, int64_t time, const TagMap& tags) = 0; + + virtual void updateGauge(const std::string& name, + int64_t amount, + const TagMap& tags) = 0; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_STATSREPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Timer.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Timer.cpp new file mode 100644 index 000000000..47ffe3fc8 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Timer.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/metrics/Timer.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Timer.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Timer.h new file mode 100644 index 000000000..8c2298883 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/metrics/Timer.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_METRICS_TIMER_H +#define JAEGERTRACING_METRICS_TIMER_H + +#include <stdint.h> + +namespace jaegertracing { +namespace metrics { + +class Timer { + public: + virtual ~Timer() = default; + + virtual void record(int64_t time) = 0; +}; + +} // namespace metrics +} // namespace jaegertracing + +#endif // JAEGERTRACING_METRICS_TIMER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddress.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddress.cpp new file mode 100644 index 000000000..44393dfc0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddress.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/platform/Hostname.h" +#include "jaegertracing/net/Socket.h" + +#include <sys/types.h> + +#ifndef WIN32 +#include <ifaddrs.h> +#endif + +namespace jaegertracing { +namespace net { + +namespace { + +template <typename T> +struct CDeleter : public std::function<void(T*)> { + void operator()(T* ifAddr) const + { +#ifdef WIN32 + free(ifAddr); +#else + if (ifAddr) { + ::freeifaddrs(ifAddr); + } +#endif + } +}; + +} // anonymous namespace + +#ifdef WIN32 + +IPAddress _localIP(int family) +{ + DWORD size = 15032; + DWORD rv = GetAdaptersAddresses( + AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, NULL, NULL, &size); + if (rv != ERROR_BUFFER_OVERFLOW) { + // GetAdaptersAddresses() failed... + return IPAddress(); + } + std::unique_ptr<IP_ADAPTER_ADDRESSES, CDeleter<IP_ADAPTER_ADDRESSES>> + adapter_addresses((IP_ADAPTER_ADDRESSES*)malloc(size)); + + rv = GetAdaptersAddresses( + AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, NULL, &*adapter_addresses, &size); + if (rv != ERROR_SUCCESS) { + // GetAdaptersAddresses() failed... + return IPAddress(); + } + + for (PIP_ADAPTER_ADDRESSES aa = &*adapter_addresses; aa != NULL; + aa = aa->Next) { + for (PIP_ADAPTER_UNICAST_ADDRESS ua = aa->FirstUnicastAddress; + ua != NULL; + ua = ua->Next) { + if (family == ua->Address.lpSockaddr->sa_family) { + char buf[BUFSIZ] = { 0 }; + getnameinfo(ua->Address.lpSockaddr, + ua->Address.iSockaddrLength, + buf, + sizeof(buf), + NULL, + 0, + NI_NUMERICHOST); + + return IPAddress(*(ua->Address.lpSockaddr), + (family == AF_INET) ? sizeof(::sockaddr_in) + : sizeof(::sockaddr_in6)); + } + } + } + + return IPAddress(); +} + +#else + +namespace { + +IPAddress _localIP(std::function<bool(const ifaddrs*)> filter) +{ + auto* ifAddrRawPtr = static_cast<ifaddrs*>(nullptr); + getifaddrs(&ifAddrRawPtr); + std::unique_ptr<ifaddrs, CDeleter<ifaddrs>> ifAddr(ifAddrRawPtr); + for (auto* itr = ifAddr.get(); itr; itr = itr->ifa_next) { + if (filter(itr)) { + const auto family = ifAddr->ifa_addr->sa_family; + const auto addrLen = (family == AF_INET) ? sizeof(::sockaddr_in) + : sizeof(::sockaddr_in6); + return IPAddress(*itr->ifa_addr, addrLen); + } + } + return IPAddress(); +} + +IPAddress _localIP(int family) +{ + return _localIP([family](const ifaddrs* ifAddr) { + return ifAddr->ifa_addr != nullptr && + ifAddr->ifa_addr->sa_family == family; + }); +} + + +} // anonymous namespace + +#endif + +IPAddress IPAddress::localIP(int family) +{ + try { + return versionFromString(platform::hostname(), 0, family); + } catch (...) { + // Fall back to returning the first matching interface + } + return _localIP(family); +} + +IPAddress +IPAddress::versionFromString(const std::string& ip, int port, int family) +{ + ::sockaddr_storage addrStorage; + std::memset(&addrStorage, 0, sizeof(addrStorage)); + + auto* addrBuffer = static_cast<void*>(nullptr); + if (family == AF_INET) { + ::sockaddr_in& addr = *reinterpret_cast<::sockaddr_in*>(&addrStorage); + addr.sin_family = family; + addr.sin_port = htons(port); + addrBuffer = &addr.sin_addr; + } + else { + assert(family == AF_INET6); + ::sockaddr_in6& addr = *reinterpret_cast<::sockaddr_in6*>(&addrStorage); + addr.sin6_family = family; + addr.sin6_port = htons(port); + addrBuffer = &addr.sin6_addr; + } + + const auto returnCode = inet_pton(family, ip.c_str(), addrBuffer); + + if (returnCode == 0) { + auto result = resolveAddress(ip, port, family); + assert(result); + std::memcpy(&addrStorage, result->ai_addr, result->ai_addrlen); + } + return IPAddress(addrStorage, + family == AF_INET ? sizeof(::sockaddr_in) + : sizeof(::sockaddr_in6)); +} + +std::unique_ptr<::addrinfo, AddrInfoDeleter> +resolveAddress(const std::string& host, int port, int family, int type) +{ +// On windows, getaddrinfo does not return an error for empty host +#ifdef WIN32 + if (host.empty()) { + throw std::runtime_error("Error resolving address: "); + } +#endif + ::addrinfo hints; + std::memset(&hints, 0, sizeof(hints)); + hints.ai_family = family; + hints.ai_socktype = type; + + std::string service; + if (port != 0) { + service = std::to_string(port); + } + + Socket::OSResource osResouce; + + auto* servInfoPtr = static_cast<::addrinfo*>(nullptr); + const auto returnCode = + getaddrinfo(host.c_str(), service.c_str(), &hints, &servInfoPtr); + std::unique_ptr<::addrinfo, AddrInfoDeleter> servInfo(servInfoPtr); + + if (returnCode != 0) { + std::ostringstream oss; + oss << "Error resolving address: " << gai_strerror(returnCode); + throw std::runtime_error(oss.str()); + } + + return servInfo; +} + +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddress.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddress.h new file mode 100644 index 000000000..46e15e899 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddress.h @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_IPADDRESS_H +#define JAEGERTRACING_NET_IPADDRESS_H + + +#include <array> +#include <cassert> +#include <cstring> +#include <functional> +#include <memory> +#include <sstream> +#include <stdexcept> +#include <system_error> +#include <vector> + +#include "jaegertracing/Compilers.h" + +#ifdef WIN32 +#include <winsock2.h> +#include <iphlpapi.h> +#include <ws2tcpip.h> +#include <windows.h> +#else +#include <arpa/inet.h> +#include <netdb.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <unistd.h> +#endif + + + + +struct ifaddrs; + +namespace jaegertracing { +namespace net { + +class IPAddress { + public: + static std::pair<std::string, int> parse(const std::string& hostPort) + { + const auto colonPos = hostPort.find(':'); + const auto ip = hostPort.substr(0, colonPos); + int port = 0; + if (colonPos != std::string::npos) { + const auto portStr = hostPort.substr(colonPos + 1); + std::istringstream iss(portStr); + if (!(iss >> port)) { + port = 0; + } + } + return std::make_pair(ip, port); + } + + static IPAddress v4(const std::string& hostPort) + { + auto result = parse(hostPort); + return v4(result.first, result.second); + } + + static IPAddress v4(const std::string& ip, int port) + { + return versionFromString(ip, port, AF_INET); + } + + static IPAddress v6(const std::string& ip, int port) + { + return versionFromString(ip, port, AF_INET6); + } + + static IPAddress localIP(int family); + + IPAddress() + : _addr() + , _addrLen(sizeof(::sockaddr_in)) + { + std::memset(&_addr, 0, sizeof(_addr)); + } + + IPAddress(const ::sockaddr_storage& addr, ::socklen_t addrLen) + : _addr(addr) + , _addrLen(addrLen) + { + } + + IPAddress(const ::sockaddr& addr, ::socklen_t addrLen) + : IPAddress() + { + std::memcpy(&_addr, &addr, addrLen); + } + + explicit IPAddress(const ::sockaddr_in& addr) + : IPAddress(reinterpret_cast<const ::sockaddr&>(addr), sizeof(addr)) + { + } + + explicit IPAddress(const ::sockaddr_in6& addr) + : IPAddress(reinterpret_cast<const ::sockaddr&>(addr), sizeof(addr)) + { + } + + bool operator==(const IPAddress& rhs) const + { + if (_addrLen != rhs._addrLen) { + return false; + } + return std::memcmp(&_addr, &rhs._addr, _addrLen) == 0; + } + + const ::sockaddr_storage& addr() const { return _addr; } + + ::socklen_t addrLen() const { return _addrLen; } + + void print(std::ostream& out) const + { + out << "{ family=" << family(); + const auto addrStr = host(); + if (!addrStr.empty()) { + out << ", addr=" << addrStr; + } + out << ", port=" << port() << " }"; + } + + std::string authority() const + { + const auto portNum = port(); + if (portNum != 0) { + return host() + ':' + std::to_string(portNum); + } + return host(); + } + + std::string host() const + { + std::array<char, INET6_ADDRSTRLEN> buffer; + const auto af = family(); + const auto* addrStr = ::inet_ntop( + af, + af == AF_INET + ? const_cast<void*>( + static_cast<const void*>( + &reinterpret_cast<const ::sockaddr_in&>(_addr).sin_addr)) + : const_cast<void*>( + static_cast<const void*>( + &reinterpret_cast<const ::sockaddr_in6&>(_addr).sin6_addr)), + &buffer[0], + buffer.size()); + return addrStr ? addrStr : ""; + } + + int port() const + { + if (family() == AF_INET) { + return ntohs( + reinterpret_cast<const ::sockaddr_in&>(_addr).sin_port); + } + return ntohs(reinterpret_cast<const ::sockaddr_in6&>(_addr).sin6_port); + } + + int family() const + { + if (_addrLen == sizeof(::sockaddr_in)) { + return AF_INET; + } + assert(_addrLen == sizeof(::sockaddr_in6)); + return AF_INET6; + } + + private: + static IPAddress versionFromString(const std::string& ip, int port, int family); + + ::sockaddr_storage _addr; + ::socklen_t _addrLen; +}; + +struct AddrInfoDeleter : public std::function<void(::addrinfo*)> { + void operator()(::addrinfo* addrInfo) const { ::freeaddrinfo(addrInfo); } +}; + +std::unique_ptr<::addrinfo, AddrInfoDeleter> resolveAddress( + const std::string& host, int port, int family, int type = SOCK_STREAM); + +} // namespace net +} // namespace jaegertracing + +inline std::ostream& operator<<(std::ostream& out, + const jaegertracing::net::IPAddress& addr) +{ + addr.print(out); + return out; +} + +#endif // JAEGERTRACING_NET_IPADDRESS_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddressTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddressTest.cpp new file mode 100644 index 000000000..6d5300d7c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/IPAddressTest.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/IPAddress.h" +#include <gtest/gtest.h> +#include <stdexcept> + +namespace jaegertracing { +namespace net { + +TEST(IPAddress, testParseFail) +{ + ASSERT_THROW(IPAddress::v4("", 0), std::runtime_error); +} + +TEST(IPAddress, testAuthority) +{ + ASSERT_EQ("127.0.0.1", IPAddress::v4("127.0.0.1", 0).authority()); + ASSERT_EQ("127.0.0.1:1234", IPAddress::v4("127.0.0.1", 1234).authority()); +} + +TEST(IPAddress, testIPv6) +{ + ASSERT_EQ("2001:db8:ac10:fe01::", + IPAddress::v6("2001:db8:ac10:fe01::", 0).authority()); +} + +TEST(IPAddress, testResolveAddress) +{ + ASSERT_NO_THROW(resolveAddress("localhost", 80, AF_INET, SOCK_STREAM)); +#ifdef WIN32 + ASSERT_THROW(resolveAddress("123456", 80, AF_INET, SOCK_STREAM), + std::runtime_error); +#else + ASSERT_NO_THROW(resolveAddress("123456", 80, AF_INET, SOCK_STREAM)); +#endif + ASSERT_THROW(resolveAddress("localhost", 80, -1), std::runtime_error); +} + +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/Socket.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/Socket.cpp new file mode 100644 index 000000000..7dc0df5bd --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/Socket.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/Socket.h" + +#ifdef WIN32 + +#include <stdio.h> +#include <windows.h> +#include <winsock2.h> +#include <ws2tcpip.h> + +#endif + +namespace jaegertracing { +namespace net { + +namespace { + + +void initSocket() +{ +#ifdef WIN32 + /* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */ + WORD wVersionRequested = MAKEWORD(2, 2); + + WSADATA wsaData; + int err = WSAStartup(wVersionRequested, &wsaData); + if (err != 0) { + std::ostringstream oss; + oss << "Failed to find a usable Winsock DLL. WSAStartup failed with " + "error " + << err; + throw std::system_error(errno, std::system_category(), oss.str()); + } + + /* Confirm that the WinSock DLL supports 2.2.*/ + /* Note that if the DLL supports versions greater */ + /* than 2.2 in addition to 2.2, it will still return */ + /* 2.2 in wVersion since that is the version we */ + /* requested. */ + + if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) { + WSACleanup(); + + std::ostringstream oss; + oss << "Failed to find a usable Winsock DLL. WSAStartup failed with " + "error " + << err; + throw std::system_error(errno, std::system_category(), oss.str()); + } +#endif +} + +void cleanSocket() +{ +#ifdef WIN32 + WSACleanup(); +#endif +} + +} + + +Socket::OSResource::OSResource() { initSocket(); } + +Socket::OSResource::~OSResource() { cleanSocket(); } + + +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/Socket.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/Socket.h new file mode 100644 index 000000000..ee936fcf4 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/Socket.h @@ -0,0 +1,245 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_SOCKET_H +#define JAEGERTRACING_NET_SOCKET_H + +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/net/URI.h" +#include <errno.h> +#include <memory> +#include <ostream> +#include <stdexcept> +#include <string> +#include <system_error> + +#ifdef WIN32 +#include <iphlpapi.h> +#include <windows.h> +#include <winsock2.h> +#include <ws2tcpip.h> + +typedef SOCKET HandleType; + +#else +#include <arpa/inet.h> +#include <netdb.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <unistd.h> + +typedef int HandleType; + +#endif + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4267) +#endif + +namespace jaegertracing { +namespace net { + + + +class Socket { + public: + Socket() + : _handle(-1) + , _family(-1) + , _type(-1) + { + } + + Socket(const Socket&) = delete; + + Socket& operator=(const Socket&) = delete; + + Socket(Socket&& socket) + : _handle(socket._handle) + , _family(socket._family) + , _type(socket._type) + { + socket._handle = -1; + } + + Socket& operator=(Socket&& rhs) + { + _handle = rhs._handle; + _family = rhs._family; + _type = rhs._type; + return *this; + } + + ~Socket() + { + close(); + } + + void open(int family, int type) + { + const auto handle = ::socket(family, type, 0); + if (isHandleInvalid(handle)) { + std::ostringstream oss; + oss << "Failed to open socket" + ", family=" + << family << ", type=" << type; + throw std::system_error(errno, std::system_category(), oss.str()); + } + _handle = handle; + _family = family; + _type = type; + } + + void bind(const IPAddress& addr) + { + const auto returnCode = + ::bind(_handle, + reinterpret_cast<const ::sockaddr*>(&addr.addr()), + addr.addrLen()); + if (returnCode != 0) { + std::ostringstream oss; + oss << "Failed to bind socket to address" + ", addr="; + addr.print(oss); + throw std::system_error(errno, std::system_category(), oss.str()); + } + } + + void bind(const std::string& ip, int port) + { + const auto addr = IPAddress::v4(ip, port); + bind(addr); + } + + void connect(const IPAddress& serverAddr) + { + const auto returnCode = + ::connect(_handle, + reinterpret_cast<const ::sockaddr*>(&serverAddr.addr()), + serverAddr.addrLen()); + if (returnCode != 0) { + std::ostringstream oss; + oss << "Cannot connect socket to remote address "; + serverAddr.print(oss); + throw std::runtime_error(oss.str()); + } + } + + IPAddress connect(const std::string& serverURIStr) + { + return connect(URI::parse(serverURIStr)); + } + + IPAddress connect(const URI& serverURI) + { + auto result = + resolveAddress(serverURI._host, serverURI._port, AF_INET, _type); + for (const auto* itr = result.get(); itr; itr = itr->ai_next) { + const auto returnCode = + ::connect(_handle, itr->ai_addr, itr->ai_addrlen); + if (returnCode == 0) { + return IPAddress(*itr->ai_addr, itr->ai_addrlen); + } + } + std::ostringstream oss; + oss << "Cannot connect socket to remote address "; + serverURI.print(oss); + throw std::runtime_error(oss.str()); + } + + static constexpr auto kDefaultBacklog = 128; + + void listen(int backlog = kDefaultBacklog) + { + const auto returnCode = ::listen(_handle, backlog); + if (returnCode != 0) { + throw std::system_error( + errno, std::system_category(), "Failed to listen on socket"); + } + } + + Socket accept() + { + ::sockaddr_storage addrStorage; + ::socklen_t addrLen = sizeof(addrStorage); + const auto clientHandle = ::accept( + _handle, reinterpret_cast<::sockaddr*>(&addrStorage), &addrLen); + + if (isHandleInvalid(clientHandle)) { + throw std::system_error( + errno, std::system_category(), "Failed to accept on socket"); + } + + Socket clientSocket; + clientSocket._handle = clientHandle; + clientSocket._family = + (addrLen == sizeof(::sockaddr_in)) ? AF_INET : AF_INET6; + clientSocket._type = SOCK_STREAM; + return clientSocket; + } + + void close() noexcept + { + if (_handle >= 0) { +#ifdef WIN32 + ::closesocket(_handle); +#else + ::close(_handle); +#endif + _handle = -1; + } + } + + HandleType handle() { return _handle; } + private: + class OSResource { + public: + OSResource(); + ~OSResource(); + + OSResource(const OSResource&) = delete; + OSResource& operator=(const OSResource&) = delete; + OSResource& operator=(const OSResource&&) = delete; + }; + + OSResource _osResource; + HandleType _handle; + int _family; + int _type; + + static bool isHandleInvalid(HandleType h) + { +#ifdef WIN32 + return (h == SOCKET_ERROR); +#else + return (h < 0); +#endif + } + + friend class IPAddress; + friend std::unique_ptr<::addrinfo, AddrInfoDeleter> + resolveAddress(const std::string& host, int port, int family, int type); +}; + +} // namespace net +} // namespace jaegertracing + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif // JAEGERTRACING_NET_SOCKET_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/SocketTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/SocketTest.cpp new file mode 100644 index 000000000..beaef6394 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/SocketTest.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/net/Socket.h" +#include "jaegertracing/net/URI.h" +#include <gtest/gtest.h> +#include <stdexcept> +#include <system_error> + +namespace jaegertracing { +namespace net { + +TEST(Socket, testFailOpen) +{ + Socket socket; + ASSERT_THROW(socket.open(-5, -10), std::system_error); +} + +// On Windows, the bind does not throw + #ifndef WIN32 +TEST(Socket, testFailBind) +{ + Socket socket; + socket.open(AF_INET, SOCK_STREAM); + ASSERT_THROW(socket.bind(IPAddress::v4("127.0.0.1", 1)), std::system_error); +} +#endif + +TEST(Socket, testFailConnect) +{ + Socket socket; + socket.open(AF_INET, SOCK_STREAM); + ASSERT_THROW(socket.connect(IPAddress::v4("127.0.0.1", 12345)), + std::runtime_error); +} + +TEST(Socket, testFailConnectURI) +{ + Socket socket; + socket.open(AF_INET, SOCK_STREAM); + const auto uri = URI::parse("http://127.0.0.1:12345"); + ASSERT_THROW(socket.connect(uri), std::runtime_error); +} + +TEST(Socket, testFailListen) +{ + Socket socket; + socket.open(AF_INET, SOCK_DGRAM); + ASSERT_THROW(socket.listen(), std::system_error); +} + +TEST(Socket, testFailAccept) +{ + Socket socket; + socket.open(AF_INET, SOCK_DGRAM); + ASSERT_THROW(socket.accept(), std::system_error); +} + +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URI.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URI.cpp new file mode 100644 index 000000000..b4adf18a2 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URI.cpp @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/URI.h" + +#include <cassert> +#include <cstring> +#include <iomanip> +#include <iostream> +#include <regex> +#include <cctype> + +namespace jaegertracing { +namespace net { +namespace { + +bool isHex(char ch) +{ + return (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || + (ch >= 'a' && ch <= 'f'); +} + +int decodeHex(char ch) +{ + if (ch >= '0' && ch <= '9') { + return ch - '0'; + } + if (ch >= 'A' && ch <= 'F') { + return ch - 'A' + 10; + } + assert(ch >= 'a' && ch <= 'f'); + return ch - 'a' + 10; +} + +bool isUnreserved(char ch) +{ + if (std::isalpha(ch) || std::isdigit(ch)) { + return true; + } + + switch (ch) { + case '-': + case '.': + case '_': + case '~': + return true; + default: + return false; + } +} + +} // anonymous namespace + +URI URI::parse(const std::string& uriStr) +{ + // See https://tools.ietf.org/html/rfc3986 for explanation. + URI uri; + std::regex uriRegex( + "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?", + std::regex::extended); + std::smatch match; + std::regex_match(uriStr, match, uriRegex); + + constexpr auto kSchemeIndex = 2; + constexpr auto kAuthorityIndex = 4; + constexpr auto kPathIndex = 5; + constexpr auto kQueryIndex = 7; + + assert(match.size() >= kQueryIndex); + + uri._scheme = match[kSchemeIndex].str(); + + const auto authority = match[kAuthorityIndex].str(); + const auto colonPos = authority.find(':'); + if (colonPos == std::string::npos) { + uri._host = authority; + } + else { + uri._host = authority.substr(0, colonPos); + const auto portStr = authority.substr(colonPos + 1); + std::istringstream iss(portStr); + iss >> uri._port; + } + + uri._path = match[kPathIndex].str(); + uri._query = match[kQueryIndex].str(); + + return uri; +} + +std::string URI::queryEscape(const std::string& input) +{ + std::ostringstream oss; + for (auto&& ch : input) { + if (isUnreserved(ch)) { + oss << ch; + } + else { + oss << '%' << std::uppercase << std::hex << static_cast<int>(ch); + } + } + return oss.str(); +} + +std::string URI::queryUnescape(const std::string& input) +{ + enum class State { kDefault, kPercent, kFirstHex }; + + std::ostringstream oss; + auto hex = 0; + auto state = State::kDefault; + for (auto&& ch : input) { + switch (state) { + case State::kDefault: { + if (ch == '%') { + state = State::kPercent; + } + else { + oss.put(ch); + } + } break; + case State::kPercent: { + if (isHex(ch)) { + state = State::kFirstHex; + hex = (decodeHex(ch) & 0xff); + } + else { + state = State::kDefault; + oss.put('%'); + oss.put(ch); + } + } break; + default: { + assert(state == State::kFirstHex); + if (isHex(ch)) { + hex <<= 4; + hex |= (decodeHex(ch) & 0xff); + oss.put(static_cast<char>(hex)); + } + else { + oss.put('%'); + oss << std::hex << hex; + oss.put(ch); + } + state = State::kDefault; + hex = 0; + } break; + } + } + return oss.str(); +} + +URI::QueryValueMap URI::parseQueryValues() const +{ + enum class State { kKey, kValue }; + + if (_query.empty()) { + return QueryValueMap(); + } + + QueryValueMap values; + auto state = State::kKey; + std::string keyBuffer; + std::string valueBuffer; + for (auto&& ch : _query) { + switch (state) { + case State::kKey: { + switch (ch) { + case '=': { + valueBuffer.clear(); + state = State::kValue; + } break; + case '&': { + values.insert(std::make_pair(queryUnescape(keyBuffer), "")); + keyBuffer.clear(); + state = State::kKey; + } break; + default: { + keyBuffer.push_back(ch); + } + } + } break; + default: { + assert(state == State::kValue); + if (ch == '&') { + values.insert(std::make_pair(queryUnescape(keyBuffer), + queryUnescape(valueBuffer))); + keyBuffer.clear(); + state = State::kKey; + } + else { + valueBuffer.push_back(ch); + } + } break; + } + } + + if (!keyBuffer.empty()) { + if (state == State::kKey) { + values.insert(std::make_pair(queryUnescape(keyBuffer), "")); + } + else if (state == State::kValue) { + values.insert(std::make_pair(queryUnescape(keyBuffer), + queryUnescape(valueBuffer))); + } + } + return values; +} + +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URI.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URI.h new file mode 100644 index 000000000..65743659a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URI.h @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_URI_H +#define JAEGERTRACING_NET_URI_H + +#include <functional> +#include <memory> +#include <sstream> +#include <string> +#include <unordered_map> + +#include "jaegertracing/Compilers.h" + +namespace jaegertracing { +namespace net { + +struct URI { + using QueryValueMap = std::unordered_multimap<std::string, std::string>; + + static URI parse(const std::string& uriStr); + + static std::string queryEscape(const std::string& input); + + static std::string queryUnescape(const std::string& input); + + URI() + : _scheme() + , _host() + , _port(0) + , _path() + , _query() + { + } + + std::string authority() const + { + if (_port != 0) { + return _host + ':' + std::to_string(_port); + } + return _host; + } + + std::string target() const + { + auto result = _path; + if (result.empty()) { + result = "/"; + } + if (!_query.empty()) { + result += '?' + _query; + } + return result; + } + + template <typename Stream> + void print(Stream& out) const + { + out << "{ scheme=\"" << _scheme << '"' << ", host=\"" << _host << '"' + << ", port=" << _port << ", path=\"" << _path << '"' << ", query=\"" + << _query << '"' << " }"; + } + + QueryValueMap parseQueryValues() const; + + std::string _scheme; + std::string _host; + int _port; + std::string _path; + std::string _query; +}; + +} // namespace net +} // namespace jaegertracing + +inline std::ostream& operator<<(std::ostream& out, + const jaegertracing::net::URI& uri) +{ + uri.print(out); + return out; +} + +#endif // JAEGERTRACING_NET_URI_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URITest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URITest.cpp new file mode 100644 index 000000000..70628b0db --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/URITest.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/URI.h" +#include <gtest/gtest.h> +#include <iosfwd> +#include <iterator> +#include <string> +#include <unordered_map> +#include <utility> + +namespace jaegertracing { +namespace net { + +TEST(URI, testMatch) +{ + ASSERT_EQ(0, URI::parse("http://localhost")._port); + ASSERT_EQ(80, URI::parse("http://localhost:80")._port); +} + +TEST(URI, testAuthority) +{ + ASSERT_EQ("localhost", URI::parse("http://localhost").authority()); + ASSERT_EQ("localhost:80", URI::parse("http://localhost:80").authority()); +} + +TEST(URI, testPrint) +{ + std::ostringstream oss; + oss << URI::parse("localhost"); + ASSERT_EQ( + "{ scheme=\"\"" + ", host=\"\"" + ", port=0" + ", path=\"localhost\"" + ", query=\"\" }", + oss.str()); +} + +TEST(URI, queryEscape) +{ + ASSERT_EQ("hello%20world", URI::queryEscape("hello world")); + ASSERT_EQ("hello-world", URI::queryEscape("hello-world")); + ASSERT_EQ("hello.world", URI::queryEscape("hello.world")); + ASSERT_EQ("hello_world", URI::queryEscape("hello_world")); + ASSERT_EQ("hello~world", URI::queryEscape("hello~world")); + ASSERT_EQ("hello%3Aworld", URI::queryEscape("hello:world")); +} + +TEST(URI, queryUnescape) +{ + ASSERT_EQ("hello world", URI::queryUnescape("hello%20world")); + ASSERT_EQ("hello%2world", URI::queryUnescape("hello%2world")); + ASSERT_EQ("hello%world", URI::queryUnescape("hello%world")); + ASSERT_EQ("hello world", URI::queryUnescape("hello w%6Frld")); + ASSERT_EQ("hello world", URI::queryUnescape("hello w%6frld")); +} + +TEST(URI, testParseQueryValues) +{ + { + const auto uri = URI::parse( + "http://example.com?test1=1&test2=%6F&test2=r&test3&test4"); + const auto values = uri.parseQueryValues(); + ASSERT_EQ(5, values.size()); + + const auto test1 = values.equal_range("test1"); + ASSERT_EQ(1, std::distance(test1.first, test1.second)); + ASSERT_EQ("test1", test1.first->first); + ASSERT_EQ("1", test1.first->second); + + const auto test2 = values.equal_range("test2"); + ASSERT_EQ(2, std::distance(test2.first, test2.second)); + auto test2Itr = test2.first; + ASSERT_EQ("test2", test2Itr->first); + ASSERT_TRUE(test2Itr->second == "o" || test2Itr->second == "r"); + auto nextTest2Value = (test2Itr->second == "o") ? "r" : "o"; + ++test2Itr; + ASSERT_EQ("test2", test2Itr->first); + ASSERT_EQ(nextTest2Value, test2Itr->second); + + const auto test3 = values.equal_range("test3"); + ASSERT_EQ(1, std::distance(test3.first, test3.second)); + ASSERT_EQ("test3", test3.first->first); + ASSERT_TRUE(test3.first->second.empty()); + + const auto test4 = values.equal_range("test4"); + ASSERT_EQ(1, std::distance(test4.first, test4.second)); + ASSERT_EQ("test4", test4.first->first); + ASSERT_TRUE(test4.first->second.empty()); + } + + ASSERT_TRUE(URI::parse("http://example.com").parseQueryValues().empty()); + + { + const auto uri = URI::parse("http://example.com?key=value"); + const auto values = uri.parseQueryValues(); + ASSERT_EQ(1, values.size()); + ASSERT_EQ("key", std::begin(values)->first); + ASSERT_EQ("value", std::begin(values)->second); + } +} + +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Error.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Error.cpp new file mode 100644 index 000000000..b280f1b3c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Error.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/http/Error.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Error.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Error.h new file mode 100644 index 000000000..e38ce24cb --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Error.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_HTTP_ERROR_H +#define JAEGERTRACING_NET_HTTP_ERROR_H + +#include <sstream> +#include <stdexcept> +#include <string> + +namespace jaegertracing { +namespace net { +namespace http { + +class ParseError : public std::invalid_argument { + public: + using invalid_argument::invalid_argument; + + static ParseError make(const std::string& expected, + const std::string& actual) + { + std::ostringstream oss; + oss << "Parse error, expected " << expected << ", encountered \"" + << actual << '"'; + return ParseError(oss.str()); + } +}; + +} // namespace http +} // namespace net +} // namespace jaegertracing + +#endif // JAEGERTRACING_NET_HTTP_ERROR_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Header.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Header.cpp new file mode 100644 index 000000000..993966a52 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Header.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/http/Header.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Header.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Header.h new file mode 100644 index 000000000..27d0d65bc --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Header.h @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_HTTP_HEADER_H +#define JAEGERTRACING_NET_HTTP_HEADER_H + +#include <cassert> +#include <regex> +#include <string> + +#include "jaegertracing/net/http/Error.h" + +namespace jaegertracing { +namespace net { +namespace http { + +class Header { + public: + Header() = default; + + Header(const std::string& key, const std::string& value) + : _key(key) + , _value(value) + { + } + + const std::string& key() const { return _key; } + + const std::string& value() const { return _value; } + + private: + std::string _key; + std::string _value; +}; + +inline std::istream& readLineCRLF(std::istream& in, std::string& line) +{ + line.clear(); + auto ch = '\0'; + auto sawCR = false; + while (in.get(ch)) { + if (sawCR) { + if (ch == '\n') { + break; + } + else { + line.push_back('\r'); + line.push_back(ch); + sawCR = false; + } + } + else { + if (ch == '\r') { + sawCR = true; + } + else { + line.push_back(ch); + } + } + } + + return in; +} + +inline void readHeaders(std::istream& in, std::vector<Header>& headers) +{ + const std::regex headerPattern("([^:]+): (.+)$"); + std::string line; + std::smatch match; + while (readLineCRLF(in, line)) { + if (line.empty()) { + break; + } + if (!std::regex_match(line, match, headerPattern) || match.size() < 3) { + throw ParseError::make("header", line); + } + headers.emplace_back(Header(match[1], match[2])); + } +} + +} // namespace http +} // namespace net +} // namespace jaegertracing + +#endif // JAEGERTRACING_NET_HTTP_HEADER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/HeaderTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/HeaderTest.cpp new file mode 100644 index 000000000..487f46927 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/HeaderTest.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/http/Header.h" +#include <gtest/gtest.h> +#include <ostream> +#include <string> +#include <vector> + +namespace jaegertracing { +namespace net { +namespace http { + +class ParseError; + +TEST(Header, readLine) +{ + std::stringstream ss; + ss << "test\r123\r\n"; + std::string line; + while (readLineCRLF(ss, line)) { + ASSERT_EQ("test\r123", line); + } +} + +TEST(Header, readHeaders) +{ + std::stringstream ss; + ss << "Bad Header\r\n"; + std::vector<Header> headers; + ASSERT_THROW(readHeaders(ss, headers), ParseError); +} + +} // namespace http +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Method.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Method.cpp new file mode 100644 index 000000000..210f40b3d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Method.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/http/Method.h" +#include <algorithm> +#include <initializer_list> +#include <iterator> + +namespace jaegertracing { +namespace net { +namespace http { + +Method parseMethod(const std::string& methodName) +{ +#ifdef WIN32 + static constexpr char* kMethodNames[] = { "OPTIONS", "GET", "HEAD", + "POST", "PUT", "DELETE", + "TRACE", "CONNECT" }; +#else + static auto kMethodNames = { "OPTIONS", "GET", "HEAD", "POST", + "PUT", "DELETE", "TRACE", "CONNECT" }; +#endif + + + auto itr = + std::find(std::begin(kMethodNames), std::end(kMethodNames), methodName); + if (itr == std::end(kMethodNames)) { + return Method::EXTENSION; + } + return static_cast<Method>(std::distance(std::begin(kMethodNames), itr)); +} + +} // namespace http +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Method.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Method.h new file mode 100644 index 000000000..223e9452f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Method.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_HTTP_METHOD_H +#define JAEGERTRACING_NET_HTTP_METHOD_H + +#include <string> + +#undef DELETE + +namespace jaegertracing { +namespace net { +namespace http { + +enum class Method { + OPTIONS, + GET, + HEAD, + POST, + PUT, + DELETE, + TRACE, + CONNECT, + EXTENSION +}; + +Method parseMethod(const std::string& methodName); + +} // namespace http +} // namespace net +} // namespace jaegertracing + +#endif // JAEGERTRACING_NET_HTTP_METHOD_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/MethodTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/MethodTest.cpp new file mode 100644 index 000000000..df371e0f3 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/MethodTest.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/http/Method.h" +#include <gtest/gtest.h> + +namespace jaegertracing { +namespace net { +namespace http { + +TEST(Method, testParse) +{ + ASSERT_EQ(Method::OPTIONS, parseMethod("OPTIONS")); + ASSERT_EQ(Method::GET, parseMethod("GET")); + ASSERT_EQ(Method::HEAD, parseMethod("HEAD")); + ASSERT_EQ(Method::POST, parseMethod("POST")); + ASSERT_EQ(Method::PUT, parseMethod("PUT")); + ASSERT_EQ(Method::DELETE, parseMethod("DELETE")); + ASSERT_EQ(Method::TRACE, parseMethod("TRACE")); + ASSERT_EQ(Method::CONNECT, parseMethod("CONNECT")); + ASSERT_EQ(Method::EXTENSION, parseMethod("post")); +} + +} // namespace http +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Request.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Request.cpp new file mode 100644 index 000000000..bd0d75569 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Request.cpp @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/http/Request.h" +#include "jaegertracing/net/http/SocketReader.h" + +#include <regex> + +namespace jaegertracing { +namespace net { +namespace http { + +Request Request::read(Socket & socket) +{ + std::string response = SocketReader::read(socket); + std::istringstream responseStream(response); + return Request::parse(responseStream); +} + +Request Request::parse(std::istream& in) +{ + const std::regex requestLinePattern( + "([A-Z]+) ([^ ]+) HTTP/([0-9]\\.[0-9])$"); + std::string line; + std::smatch match; + if (!readLineCRLF(in, line) || + !std::regex_match(line, match, requestLinePattern) || + match.size() < 4) { + throw ParseError::make("request line", line); + } + Request request; + + request._method = parseMethod(match[1]); + request._target = match[2]; + request._version = match[3]; + + readHeaders(in, request._headers); + request._body = std::string(std::istreambuf_iterator<char>(in), + std::istreambuf_iterator<char>{}); + + return request; +} + +} // namespace http +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Request.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Request.h new file mode 100644 index 000000000..3e5f5a9c1 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Request.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_HTTP_REQUEST_H +#define JAEGERTRACING_NET_HTTP_REQUEST_H + +#include "jaegertracing/net/URI.h" +#include "jaegertracing/net/Socket.h" +#include "jaegertracing/net/http/Error.h" +#include "jaegertracing/net/http/Header.h" +#include "jaegertracing/net/http/Method.h" + +namespace jaegertracing { +namespace net { +namespace http { + +class Request { + public: + static Request parse(std::istream& in); + + static Request read(Socket& in); + + Request() + : _method() + , _target() + , _version() + , _headers() + { + } + + Method method() const { return _method; } + + const std::string& target() const { return _target; } + + const std::string& version() const { return _version; } + + const std::vector<Header>& headers() const { return _headers; } + + const std::string& body() const { return _body; } + + private: + Method _method; + std::string _target; + std::string _version; + std::vector<Header> _headers; + std::string _body; +}; + +} // namespace http +} // namespace net +} // namespace jaegertracing + +#endif // JAEGERTRACING_NET_HTTP_REQUEST_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Response.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Response.cpp new file mode 100644 index 000000000..6de74e746 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Response.cpp @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/http/Response.h" +#include "jaegertracing/net/http/SocketReader.h" + +#include <regex> +#include <sstream> +#include <stdexcept> + +#include "jaegertracing/Constants.h" +#include "jaegertracing/net/Socket.h" + +#ifdef _MSC_VER +#pragma warning(disable : 4267) +#endif + +namespace jaegertracing { +namespace net { +namespace http { + +Response Response::parse(std::istream& in) +{ + const std::regex statusLinePattern("HTTP/([0-9]\\.[0-9]) ([0-9]+) (.+)$"); + std::string line; + std::smatch match; + if (!readLineCRLF(in, line) || + !std::regex_match(line, match, statusLinePattern) || match.size() < 4) { + throw ParseError::make("status line", line); + } + Response response; + response._version = match[1]; + std::istringstream iss(match[2]); + iss >> response._statusCode; + response._reason = match[3]; + + readHeaders(in, response._headers); + + response._body = std::string(std::istreambuf_iterator<char>(in), + std::istreambuf_iterator<char>{}); + + return response; +} + +Response read(Socket & socket) +{ + std::string response = SocketReader::read(socket); + std::istringstream responseStream(response); + return Response::parse(responseStream); +} + +Response get(const URI& uri) +{ + Socket socket; + socket.open(AF_INET, SOCK_STREAM); + socket.connect(uri); + std::ostringstream requestStream; + requestStream << "GET " << uri.target() << " HTTP/1.1\r\n" + << "Host: " << uri.authority() + << "\r\n" + "User-Agent: jaegertracing/" + << kJaegerClientVersion << "\r\n\r\n"; + const auto request = requestStream.str(); +#ifdef WIN32 + const auto numWritten = ::send(socket.handle(), request.c_str(), request.size(), 0); +#else + const auto numWritten = ::write(socket.handle(), request.c_str(), request.size()); +#endif + if (numWritten != static_cast<int>(request.size())) { + std::ostringstream oss; + oss << "Failed to write entire HTTP request" + << ", uri=" << uri << ", request=" << request; + throw std::system_error(errno, std::system_category(), oss.str()); + } + + return read(socket); +} + +} // namespace http +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Response.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Response.h new file mode 100644 index 000000000..59a0fe9b0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/Response.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_HTTP_RESPONSE_H +#define JAEGERTRACING_NET_HTTP_RESPONSE_H + +#include "jaegertracing/net/URI.h" +#include "jaegertracing/net/Socket.h" +#include "jaegertracing/net/http/Error.h" +#include "jaegertracing/net/http/Header.h" +#include "jaegertracing/net/http/Method.h" + +namespace jaegertracing { +namespace net { +namespace http { + +class Response { + public: + static Response parse(std::istream& in); + + Response() + : _version() + , _statusCode(0) + , _reason() + , _headers() + , _body() + { + } + + int statusCode() const { return _statusCode; } + + const std::string& reason() const { return _reason; } + + const std::vector<Header>& headers() const { return _headers; } + + const std::string& body() const { return _body; } + + private: + std::string _version; + int _statusCode; + std::string _reason; + std::vector<Header> _headers; + std::string _body; +}; + +Response get(const URI& uri); + +/** + * Reads http response from a socket + */ +Response read(Socket& socket); + +} // namespace http +} // namespace net +} // namespace jaegertracing + +#endif // JAEGERTRACING_NET_HTTP_RESPONSE_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/ResponseTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/ResponseTest.cpp new file mode 100644 index 000000000..9227f2c41 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/ResponseTest.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Constants.h" +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/net/Socket.h" +#include "jaegertracing/net/URI.h" +#include "jaegertracing/net/http/Response.h" +#include <array> +#include <future> +#include <gtest/gtest.h> +#include <ostream> +#include <string> +#include <thread> + +#ifdef _MSC_VER +#pragma warning(disable : 4267) +#pragma warning(disable : 4244) +#endif + +namespace jaegertracing { +namespace net { +namespace http { + +namespace { + +#ifdef WIN32 +#define READ_ERROR SOCKET_ERROR +#else +#define READ_ERROR -1 +#endif + +static size_t read(int socketHandle, char* buffer, size_t size) +{ + int returnValue = ::recv(socketHandle, buffer, size, 0); + return (returnValue == READ_ERROR) ? 0 : returnValue; +} +} + +TEST(Response, get) +{ + IPAddress serverAddress; + std::promise<void> started; + + std::thread clientThread([&serverAddress, &started]() { + started.get_future().wait(); + get(URI::parse("http://" + serverAddress.authority())); + }); + + Socket socket; + socket.open(AF_INET, SOCK_STREAM); + socket.bind(IPAddress::v4("127.0.0.1", 0)); + socket.listen(); + + ::sockaddr_storage addrStorage; + ::socklen_t addrLen = sizeof(addrStorage); + const auto returnCode = ::getsockname( + socket.handle(), reinterpret_cast<::sockaddr*>(&addrStorage), &addrLen); + ASSERT_EQ(0, returnCode); + serverAddress = IPAddress(addrStorage, addrLen); + + started.set_value(); + + auto clientSocket = socket.accept(); + std::array<char, 256> buffer; + + const auto numRead = read(clientSocket.handle(), &buffer[0], buffer.size()); + + std::ostringstream oss; + oss << "GET / HTTP/1.1\r\n" + "Host: 127.0.0.1:" + << serverAddress.port() << "\r\n" + << "User-Agent: jaegertracing/" << kJaegerClientVersion << "\r\n\r\n"; + ASSERT_EQ(oss.str(), std::string(&buffer[0], numRead)); + + oss.str(""); + oss.clear(); + + std::string response("HTTP/1.1 200 OK\r\n\r\n"); + response.append(buffer.size() * 2, '0'); + const auto numWritten = + ::send(clientSocket.handle(), response.c_str(), response.size(), 0); + ASSERT_EQ(response.size(), numWritten); + + clientThread.join(); +} + +} // namespace http +} // namespace net +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/SocketReader.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/SocketReader.h new file mode 100644 index 000000000..cbaaf21c6 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/net/http/SocketReader.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2018, The Jaeger Authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_NET_HTTP_SOCKET_READER_H +#define JAEGERTRACING_NET_HTTP_SOCKET_READER_H + +#include "jaegertracing/net/Socket.h" + +namespace jaegertracing { +namespace net { +namespace http { + +class SocketReader { + public: + static std::string read(Socket& socket) { + constexpr auto kBufferSize = 1024; + std::array<char, kBufferSize> buffer{}; + auto numRead = ::recv(socket.handle(), &buffer[0], buffer.size(), 0); + std::string response; + while (numRead > 0) { + response.append(&buffer[0], numRead); + if (numRead < static_cast<int>(buffer.size())) { + break; + } + numRead = ::recv(socket.handle(), &buffer[0], buffer.size(), 0); + } + return response; + } +}; + +} // namespace http +} // namespace net +} // namespace jaegertracing + +#endif // JAEGERTRACING_NET_HTTP_SOCKET_READER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Endian.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Endian.cpp new file mode 100644 index 000000000..e5d0f73e6 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Endian.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/platform/Endian.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Endian.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Endian.h new file mode 100644 index 000000000..52754ed0e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Endian.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_PLATFORM_ENDIAN_H +#define JAEGERTRACING_PLATFORM_ENDIAN_H + +#include <cstdint> + +#if defined(__APPLE__) + +#include <libkern/OSByteOrder.h> +#define htobe16(x) OSSwapHostToBigInt16(x) +#define htobe32(x) OSSwapHostToBigInt32(x) +#define htobe64(x) OSSwapHostToBigInt64(x) +#define be16toh(x) OSSwapBigToHostInt16(x) +#define be32toh(x) OSSwapBigToHostInt32(x) +#define be64toh(x) OSSwapBigToHostInt64(x) + +#elif defined(__linux__) +#include <endian.h> +#elif defined WIN32 +#include <winsock2.h> + +#if BYTE_ORDER == LITTLE_ENDIAN + +#define htobe16(x) htons(x) +#define be16toh(x) ntohs(x) + +#define htobe32(x) htonl(x) +#define be32toh(x) ntohl(x) + +#define htobe64(x) htonll(x) +#define be64toh(x) ntohll(x) +#elif BYTE_ORDER == BIG_ENDIAN +#define htobe16(x) (x) +#define be16toh(x) (x) + +#define htobe32(x) (x) +#define be32toh(x) (x) + +#define htobe64(x) (x) +#define be64toh(x) (x) +#else +#error byte order not supported +#endif +#else +#error "unsupported platform" +#endif + +namespace jaegertracing { +namespace platform { +namespace endian { + +inline uint16_t toBigEndian(uint16_t value) { return htobe16(value); } + +inline uint32_t toBigEndian(uint32_t value) { return htobe32(value); } + +inline uint64_t toBigEndian(uint64_t value) { return htobe64(value); } + +inline uint16_t fromBigEndian(uint16_t value) { return be16toh(value); } + +inline uint32_t fromBigEndian(uint32_t value) { return be32toh(value); } + +inline uint64_t fromBigEndian(uint64_t value) { return be64toh(value); } + +} // namespace endian +} // namespace platform +} // namespace jaegertracing + +#endif // JAEGERTRACING_PLATFORM_ENDIAN_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Hostname.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Hostname.cpp new file mode 100644 index 000000000..a0d5bebad --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Hostname.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/platform/Hostname.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Hostname.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Hostname.h new file mode 100644 index 000000000..d5c717798 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/platform/Hostname.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_PLATFORM_HOSTNAME_H +#define JAEGERTRACING_PLATFORM_HOSTNAME_H + +#include <errno.h> +#include <string> +#include <system_error> + +#ifdef WIN32 +#include <Winsock2.h> +#else +#include <unistd.h> +#endif + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4267) +#endif + +namespace jaegertracing { +namespace platform { + +inline std::string hostname() +{ + constexpr auto kBufferSize = 256; + std::string buffer(kBufferSize, '\0'); + const auto returnCode = ::gethostname(&buffer[0], buffer.size()); + if (returnCode != 0) { + throw std::system_error( + errno, std::system_category(), "Failed to get hostname"); + } + const auto nullPos = buffer.find('\0'); + return buffer.substr(0, nullPos); +} + +} // namespace platform +} // namespace jaegertracing + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif // JAEGERTRACING_PLATFORM_HOSTNAME_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Extractor.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Extractor.cpp new file mode 100644 index 000000000..67ee2e534 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Extractor.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/propagation/Extractor.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Extractor.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Extractor.h new file mode 100644 index 000000000..236659029 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Extractor.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_PROPAGATION_EXTRACTOR_H +#define JAEGERTRACING_PROPAGATION_EXTRACTOR_H + +#include <opentracing/propagation.h> + +#include "jaegertracing/SpanContext.h" + +namespace jaegertracing { +namespace propagation { + +template <typename Reader> +class Extractor { + public: + virtual ~Extractor() = default; + + virtual SpanContext extract(Reader reader) const = 0; +}; + +} // namespace propagation +} // namespace jaegertracing + +#endif // JAEGERTRACING_PROPAGATION_EXTRACTOR_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/HeadersConfig.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/HeadersConfig.cpp new file mode 100644 index 000000000..87d667d0d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/HeadersConfig.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/propagation/HeadersConfig.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/HeadersConfig.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/HeadersConfig.h new file mode 100644 index 000000000..4ae213555 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/HeadersConfig.h @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_PROPAGATION_HEADERSCONFIG_H +#define JAEGERTRACING_PROPAGATION_HEADERSCONFIG_H + +#include "jaegertracing/Constants.h" +#include "jaegertracing/utils/YAML.h" +#include <string> + +namespace jaegertracing { +namespace propagation { + +class HeadersConfig { + public: +#ifdef JAEGERTRACING_WITH_YAML_CPP + + static HeadersConfig parse(const YAML::Node& configYAML) + { + if (!configYAML.IsDefined() || !configYAML.IsMap()) { + return HeadersConfig(); + } + + const auto jaegerDebugHeader = utils::yaml::findOrDefault<std::string>( + configYAML, "jaegerDebugHeader", ""); + const auto jaegerBaggageHeader = + utils::yaml::findOrDefault<std::string>( + configYAML, "jaegerBaggageHeader", ""); + const auto traceContextHeaderName = + utils::yaml::findOrDefault<std::string>( + configYAML, "TraceContextHeaderName", ""); + const auto traceBaggageHeaderPrefix = + utils::yaml::findOrDefault<std::string>( + configYAML, "traceBaggageHeaderPrefix", ""); + + return HeadersConfig(jaegerDebugHeader, + jaegerBaggageHeader, + traceContextHeaderName, + traceBaggageHeaderPrefix); + } + +#endif // JAEGERTRACING_WITH_YAML_CPP + + HeadersConfig() + : HeadersConfig("", "", "", "") + { + } + + HeadersConfig(const std::string& jaegerDebugHeader, + const std::string& jaegerBaggageHeader, + const std::string& traceContextHeaderName, + const std::string& traceBaggageHeaderPrefix) + : _jaegerDebugHeader(jaegerDebugHeader.empty() ? kJaegerDebugHeader + : jaegerDebugHeader) + , _jaegerBaggageHeader(jaegerBaggageHeader.empty() + ? kJaegerBaggageHeader + : jaegerBaggageHeader) + , _traceContextHeaderName(traceContextHeaderName.empty() + ? kTraceContextHeaderName + : traceContextHeaderName) + , _traceBaggageHeaderPrefix(traceBaggageHeaderPrefix.empty() + ? kTraceBaggageHeaderPrefix + : traceBaggageHeaderPrefix) + { + } + + const std::string& jaegerBaggageHeader() const + { + return _jaegerBaggageHeader; + } + + const std::string& jaegerDebugHeader() const { return _jaegerDebugHeader; } + + const std::string& traceBaggageHeaderPrefix() const + { + return _traceBaggageHeaderPrefix; + } + + const std::string& traceContextHeaderName() const + { + return _traceContextHeaderName; + } + + private: + std::string _jaegerDebugHeader; + std::string _jaegerBaggageHeader; + std::string _traceContextHeaderName; + std::string _traceBaggageHeaderPrefix; +}; + +} // namespace propagation +} // namespace jaegertracing + +#endif // JAEGERTRACING_PROPAGATION_HEADERSCONFIG_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Injector.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Injector.cpp new file mode 100644 index 000000000..15684103c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Injector.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/propagation/Injector.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Injector.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Injector.h new file mode 100644 index 000000000..f6dbb4654 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Injector.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_PROPAGATION_INJECTOR_H +#define JAEGERTRACING_PROPAGATION_INJECTOR_H + +#include <opentracing/propagation.h> + +namespace jaegertracing { + +class SpanContext; + +namespace propagation { + +template <typename Writer> +class Injector { + public: + virtual ~Injector() = default; + + virtual void inject(const SpanContext& ctx, Writer writer) const = 0; +}; + +} // namespace propagation +} // namespace jaegertracing + +#endif // JAEGERTRACING_PROPAGATION_INJECTOR_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Propagator.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Propagator.cpp new file mode 100644 index 000000000..f26f7a944 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Propagator.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/propagation/Propagator.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Propagator.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Propagator.h new file mode 100644 index 000000000..bf04be81f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/Propagator.h @@ -0,0 +1,321 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_PROPAGATION_PROPAGATOR_H +#define JAEGERTRACING_PROPAGATION_PROPAGATOR_H + +#include "jaegertracing/SpanContext.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/net/URI.h" +#include "jaegertracing/platform/Endian.h" +#include "jaegertracing/propagation/Extractor.h" +#include "jaegertracing/propagation/HeadersConfig.h" +#include "jaegertracing/propagation/Injector.h" +#include <cctype> +#include <climits> +#include <opentracing/propagation.h> +#include <sstream> + +namespace jaegertracing { + +class Tracer; + +namespace propagation { + +template <typename ReaderType, typename WriterType> +class Propagator : public Extractor<ReaderType>, public Injector<WriterType> { + public: + using Reader = ReaderType; + using Writer = WriterType; + using StrMap = SpanContext::StrMap; + + Propagator() + : _headerKeys() + , _metrics(metrics::Metrics::makeNullMetrics()) + { + } + + Propagator(const HeadersConfig& headerKeys, + const std::shared_ptr<metrics::Metrics>& metrics) + : _headerKeys(headerKeys) + , _metrics(metrics) + { + } + + virtual ~Propagator() = default; + + SpanContext extract(const Reader& reader) const override + { + SpanContext ctx; + StrMap baggage; + std::string debugID; + const auto result = reader.ForeachKey( + [this, &ctx, &debugID, &baggage](const std::string& rawKey, + const std::string& value) { + const auto key = normalizeKey(rawKey); + if (key == _headerKeys.traceContextHeaderName()) { + const auto safeValue = decodeValue(value); + std::istringstream iss(safeValue); + if (!(iss >> ctx) || ctx == SpanContext()) { + return opentracing::make_expected_from_error<void>( + opentracing::span_context_corrupted_error); + } + } + else if (key == _headerKeys.jaegerDebugHeader()) { + debugID = value; + } + else if (key == _headerKeys.jaegerBaggageHeader()) { + for (auto&& pair : parseCommaSeparatedMap(value)) { + baggage[pair.first] = pair.second; + } + } + else { + const auto prefix = _headerKeys.traceBaggageHeaderPrefix(); + if (key.size() >= prefix.size() && + key.substr(0, prefix.size()) == prefix) { + const auto safeKey = removeBaggageKeyPrefix(key); + const auto safeValue = decodeValue(value); + baggage[safeKey] = safeValue; + } + } + return opentracing::make_expected(); + }); + + if (!result && + result.error() == opentracing::span_context_corrupted_error) { + _metrics->decodingErrors().inc(1); + return SpanContext(); + } + + if (!ctx.traceID().isValid() && debugID.empty() && baggage.empty()) { + return SpanContext(); + } + + int flags = ctx.flags(); + if (!debugID.empty()) { + flags |= static_cast<unsigned char>(SpanContext::Flag::kDebug) | + static_cast<unsigned char>(SpanContext::Flag::kSampled); + } + return SpanContext(ctx.traceID(), + ctx.spanID(), + ctx.parentID(), + flags, + baggage, + debugID); + } + + void inject(const SpanContext& ctx, const Writer& writer) const override + { + std::ostringstream oss; + oss << ctx; + writer.Set(_headerKeys.traceContextHeaderName(), oss.str()); + ctx.forEachBaggageItem( + [this, &writer](const std::string& key, const std::string& value) { + const auto safeKey = addBaggageKeyPrefix(key); + const auto safeValue = encodeValue(value); + writer.Set(safeKey, safeValue); + return true; + }); + } + + protected: + virtual std::string encodeValue(const std::string& str) const + { + return str; + } + + virtual std::string decodeValue(const std::string& str) const + { + return str; + } + + virtual std::string normalizeKey(const std::string& rawKey) const + { + return rawKey; + } + + private: + static StrMap parseCommaSeparatedMap(const std::string& escapedValue) + { + StrMap map; + std::istringstream iss(net::URI::queryUnescape(escapedValue)); + std::string piece; + while (std::getline(iss, piece, ',')) { + const auto eqPos = piece.find('='); + if (eqPos != std::string::npos) { + const auto key = piece.substr(0, eqPos); + const auto value = piece.substr(eqPos + 1); + map[key] = value; + } + } + return map; + } + + std::string addBaggageKeyPrefix(const std::string& key) const + { + return _headerKeys.traceBaggageHeaderPrefix() + key; + } + + std::string removeBaggageKeyPrefix(const std::string& key) const + { + return key.substr(_headerKeys.traceBaggageHeaderPrefix().size()); + } + + HeadersConfig _headerKeys; + std::shared_ptr<metrics::Metrics> _metrics; +}; + +using TextMapPropagator = Propagator<const opentracing::TextMapReader&, + const opentracing::TextMapWriter&>; + +class HTTPHeaderPropagator + : public Propagator<const opentracing::HTTPHeadersReader&, + const opentracing::HTTPHeadersWriter&> { + public: + using Propagator<Reader, Writer>::Propagator; + + protected: + std::string encodeValue(const std::string& str) const override + { + return net::URI::queryEscape(str); + } + + std::string decodeValue(const std::string& str) const override + { + return net::URI::queryUnescape(str); + } + + std::string normalizeKey(const std::string& rawKey) const override + { + std::string key; + key.reserve(rawKey.size()); + std::transform(std::begin(rawKey), + std::end(rawKey), + std::back_inserter(key), + [](char ch) { return std::tolower(ch); }); + return key; + } +}; + +class BinaryPropagator : public Extractor<std::istream&>, + public Injector<std::ostream&> { + public: + using StrMap = SpanContext::StrMap; + + explicit BinaryPropagator(const std::shared_ptr<metrics::Metrics>& metrics = + std::shared_ptr<metrics::Metrics>()) + : _metrics(metrics == nullptr ? metrics::Metrics::makeNullMetrics() + : metrics) + { + } + + void inject(const SpanContext& ctx, std::ostream& out) const override + { + writeBinary(out, ctx.traceID().high()); + writeBinary(out, ctx.traceID().low()); + writeBinary(out, ctx.spanID()); + writeBinary(out, ctx.parentID()); + // `flags` is a single byte, so endianness is not an issue. + out.put(ctx.flags()); + + writeBinary(out, static_cast<uint32_t>(ctx.baggage().size())); + for (auto&& pair : ctx.baggage()) { + auto&& key = pair.first; + writeBinary(out, static_cast<uint32_t>(key.size())); + out.write(key.c_str(), key.size()); + + auto&& value = pair.second; + writeBinary(out, static_cast<uint32_t>(value.size())); + out.write(value.c_str(), value.size()); + } + } + + SpanContext extract(std::istream& in) const override + { + const auto traceIDHigh = readBinary<uint64_t>(in); + const auto traceIDLow = readBinary<uint64_t>(in); + TraceID traceID(traceIDHigh, traceIDLow); + const auto spanID = readBinary<uint64_t>(in); + const auto parentID = readBinary<uint64_t>(in); + + auto ch = '\0'; + in.get(ch); + const auto flags = static_cast<unsigned char>(ch); + + const auto numBaggageItems = readBinary<uint32_t>(in); + StrMap baggage; + baggage.reserve(numBaggageItems); + for (auto i = static_cast<uint32_t>(0); i < numBaggageItems; ++i) { + const auto keyLength = readBinary<uint32_t>(in); + std::string key(keyLength, '\0'); + if (!in.read(&key[0], keyLength)) { + _metrics->decodingErrors().inc(1); + return SpanContext(); + } + + const auto valueLength = readBinary<uint32_t>(in); + std::string value(valueLength, '\0'); + if (!in.read(&value[0], valueLength)) { + _metrics->decodingErrors().inc(1); + return SpanContext(); + } + + baggage[key] = value; + } + + SpanContext ctx(traceID, spanID, parentID, flags, baggage); + return ctx; + } + + private: + template <typename ValueType> + static + typename std::enable_if<std::is_integral<ValueType>::value, void>::type + writeBinary(std::ostream& out, ValueType value) + { + const ValueType outValue = platform::endian::toBigEndian(value); + for (auto i = static_cast<size_t>(0); i < sizeof(ValueType); ++i) { + const auto numShiftBits = (sizeof(ValueType) - i - 1) * CHAR_BIT; + const auto byte = outValue >> numShiftBits; + out.put(static_cast<unsigned char>(byte)); + } + } + + template <typename ValueType> + static typename std::enable_if<std::is_integral<ValueType>::value, + ValueType>::type + readBinary(std::istream& in) + { + auto value = static_cast<ValueType>(0); + auto ch = '\0'; + for (auto i = static_cast<size_t>(0); + i < sizeof(ValueType) && in.get(ch); + ++i) { + const auto byte = static_cast<uint8_t>(ch); + value <<= CHAR_BIT; + value |= byte; + } + return platform::endian::fromBigEndian(value); + } + + private: + std::shared_ptr<metrics::Metrics> _metrics; +}; + +} // namespace propagation +} // namespace jaegertracing + +#endif // JAEGERTRACING_PROPAGATION_PROPAGATOR_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/PropagatorTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/PropagatorTest.cpp new file mode 100644 index 000000000..05fc44c4f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/propagation/PropagatorTest.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/propagation/Propagator.h" +#include "jaegertracing/SpanContext.h" +#include "jaegertracing/TraceID.h" +#include <gtest/gtest.h> +#include <iosfwd> +#include <random> +#include <stddef.h> +#include <string> +#include <unordered_map> + +namespace jaegertracing { +namespace propagation { +namespace { + +template <typename RandomGenerator> +std::string randomStr(RandomGenerator& gen) +{ + constexpr auto kMaxSize = 10; + static constexpr char kLetters[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + constexpr auto kNumLetters = sizeof(kLetters) - 1; + const auto size = gen() % kMaxSize; + std::string result(size, '\0'); + for (auto i = static_cast<size_t>(0); i < size; ++i) { + const auto pos = gen() % kNumLetters; + result[i] = kLetters[pos]; + } + return result; +} + +} // anonymous namespace + +TEST(Propagator, testBinaryPropagation) +{ + std::stringstream ss; + BinaryPropagator binaryPropagator; + std::random_device randomDevice; + std::default_random_engine engine(randomDevice()); + constexpr auto kMaxNumBaggageItems = 10; + const auto numBaggageItems = engine() % (kMaxNumBaggageItems - 1) + 1; + SpanContext::StrMap baggage; + for (auto i = static_cast<size_t>(0); i < numBaggageItems; ++i) { + const auto key = randomStr(engine); + const auto value = randomStr(engine); + baggage[key] = value; + } + SpanContext ctx( + TraceID(engine(), engine()), engine(), engine(), 0, baggage); + binaryPropagator.inject(ctx, ss); + ASSERT_EQ(ctx, binaryPropagator.extract(ss)); +} + +} // namespace propagation +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/CompositeReporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/CompositeReporter.cpp new file mode 100644 index 000000000..4b9806254 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/CompositeReporter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/reporters/CompositeReporter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/CompositeReporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/CompositeReporter.h new file mode 100644 index 000000000..02f2f77d9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/CompositeReporter.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_REPORTERS_COMPOSITEREPORTER_H +#define JAEGERTRACING_REPORTERS_COMPOSITEREPORTER_H + +#include "jaegertracing/reporters/Reporter.h" +#include <algorithm> +#include <iterator> +#include <memory> +#include <vector> + +namespace jaegertracing { +class Span; +} // namespace jaegertracing + +namespace jaegertracing { +namespace reporters { + +class CompositeReporter : public Reporter { + public: + using ReporterPtr = std::shared_ptr<Reporter>; + + explicit CompositeReporter(const std::vector<ReporterPtr>& reporters) + : _reporters(reporters) + { + } + + ~CompositeReporter() { close(); } + + void report(const Span& span) noexcept override + { + std::for_each( + std::begin(_reporters), + std::end(_reporters), + [&span](const ReporterPtr& reporter) { reporter->report(span); }); + } + + void close() noexcept override + { + std::for_each(std::begin(_reporters), + std::end(_reporters), + [](const ReporterPtr& reporter) { reporter->close(); }); + } + + private: + std::vector<ReporterPtr> _reporters; +}; + +} // namespace reporters +} // namespace jaegertracing + +#endif // JAEGERTRACING_REPORTERS_COMPOSITEREPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Config.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Config.cpp new file mode 100644 index 000000000..c099574ad --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Config.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <algorithm> + +#include "jaegertracing/reporters/Config.h" +#include "jaegertracing/ThriftSender.h" +#include "jaegertracing/reporters/CompositeReporter.h" +#include "jaegertracing/reporters/LoggingReporter.h" +#include "jaegertracing/reporters/RemoteReporter.h" +#include "jaegertracing/utils/EnvVariable.h" + +namespace jaegertracing { +namespace reporters { + +constexpr int Config::kDefaultQueueSize; +constexpr const char* Config::kDefaultLocalAgentHostPort; +constexpr const char* Config::kDefaultEndpoint; +constexpr const char* Config::kJAEGER_AGENT_HOST_ENV_PROP; +constexpr const char* Config::kJAEGER_AGENT_PORT_ENV_PROP; +constexpr const char* Config::kJAEGER_ENDPOINT_ENV_PROP; + +constexpr const char* Config::kJAEGER_REPORTER_LOG_SPANS_ENV_PROP; +constexpr const char* Config::kJAEGER_REPORTER_FLUSH_INTERVAL_ENV_PROP; +constexpr const char* Config::kJAEGER_REPORTER_MAX_QUEUE_SIZE_ENV_PROP; + +std::unique_ptr<Reporter> Config::makeReporter(const std::string& serviceName, + logging::Logger& logger, + metrics::Metrics& metrics) const +{ + std::unique_ptr<utils::Transport> transporter = + _endpoint.empty() + ? (std::unique_ptr<utils::Transport>(new utils::UDPTransporter( + net::IPAddress::v4(_localAgentHostPort), 0))) + : (std::unique_ptr<utils::Transport>( + new utils::HTTPTransporter(net::URI::parse(_endpoint), 0))); + + std::unique_ptr<ThriftSender> sender(new ThriftSender( + std::forward<std::unique_ptr<utils::Transport>>(transporter))); + std::unique_ptr<RemoteReporter> remoteReporter(new RemoteReporter( + _bufferFlushInterval, _queueSize, std::move(sender), logger, metrics)); + if (_logSpans) { + logger.info("Initializing logging reporter"); + return std::unique_ptr<CompositeReporter>(new CompositeReporter( + { std::shared_ptr<RemoteReporter>(std::move(remoteReporter)), + std::make_shared<LoggingReporter>(logger) })); + } + return std::unique_ptr<Reporter>(std::move(remoteReporter)); +} + +void Config::fromEnv() +{ + const auto agentHost = + utils::EnvVariable::getStringVariable(kJAEGER_AGENT_HOST_ENV_PROP); + if (!agentHost.empty()) { + auto agentHostPort = net::IPAddress::parse(_localAgentHostPort); + std::ostringstream oss; + oss << agentHost << ":" << agentHostPort.second; + _localAgentHostPort = oss.str(); + } + const auto agentPort = + utils::EnvVariable::getStringVariable(kJAEGER_AGENT_PORT_ENV_PROP); + if (!agentPort.empty()) { + std::istringstream iss(agentPort); + int port = 0; + if (iss >> port) { + auto agentHostPort = net::IPAddress::parse(_localAgentHostPort); + std::ostringstream oss; + oss << agentHostPort.first << ":" << port; + _localAgentHostPort = oss.str(); + } + } + + const auto endpoint = + utils::EnvVariable::getStringVariable(kJAEGER_ENDPOINT_ENV_PROP); + if (!endpoint.empty()) { + _endpoint = endpoint; + } + + const auto logSpan = utils::EnvVariable::getBoolVariable( + kJAEGER_REPORTER_LOG_SPANS_ENV_PROP); + if (logSpan.first) { + _logSpans = logSpan.second; + } + + const auto flushInterval = utils::EnvVariable::getIntVariable( + kJAEGER_REPORTER_FLUSH_INTERVAL_ENV_PROP); + if (!flushInterval.first) { + if (flushInterval.second > 0) { + _bufferFlushInterval = + std::chrono::milliseconds(flushInterval.second); + } + } + + const auto maxQueueSize = utils::EnvVariable::getIntVariable( + kJAEGER_REPORTER_MAX_QUEUE_SIZE_ENV_PROP); + if (!maxQueueSize.first) { + if (maxQueueSize.second > 0) { + _queueSize = maxQueueSize.second; + } + } +} + +} // namespace reporters +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Config.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Config.h new file mode 100644 index 000000000..8f6904d2e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Config.h @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_REPORTERS_CONFIG_H +#define JAEGERTRACING_REPORTERS_CONFIG_H + +#include <chrono> +#include <memory> +#include <string> +#include <utility> + +#include "jaegertracing/Logging.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/reporters/Reporter.h" +#include "jaegertracing/utils/YAML.h" +#include "jaegertracing/utils/HTTPTransporter.h" +#include "jaegertracing/utils/UDPTransporter.h" + +namespace jaegertracing { +namespace reporters { + +class Config { + public: + using Clock = std::chrono::steady_clock; + + static constexpr auto kDefaultQueueSize = 100; + static constexpr auto kDefaultLocalAgentHostPort = "127.0.0.1:6831"; + static constexpr auto kDefaultEndpoint = ""; + + static constexpr auto kJAEGER_AGENT_HOST_ENV_PROP = "JAEGER_AGENT_HOST"; + static constexpr auto kJAEGER_AGENT_PORT_ENV_PROP = "JAEGER_AGENT_PORT"; + static constexpr auto kJAEGER_ENDPOINT_ENV_PROP = "JAEGER_ENDPOINT"; + + static constexpr auto kJAEGER_REPORTER_LOG_SPANS_ENV_PROP = "JAEGER_REPORTER_LOG_SPANS"; + static constexpr auto kJAEGER_REPORTER_FLUSH_INTERVAL_ENV_PROP = "JAEGER_REPORTER_FLUSH_INTERVAL"; + static constexpr auto kJAEGER_REPORTER_MAX_QUEUE_SIZE_ENV_PROP = "JAEGER_REPORTER_MAX_QUEUE_SIZE"; + + + + static Clock::duration defaultBufferFlushInterval() + { + return std::chrono::seconds(10); + } + +#ifdef JAEGERTRACING_WITH_YAML_CPP + + static Config parse(const YAML::Node& configYAML) + { + if (!configYAML.IsDefined() || !configYAML.IsMap()) { + return Config(); + } + + const auto queueSize = + utils::yaml::findOrDefault<int>(configYAML, "queueSize", 0); + const auto bufferFlushInterval = + std::chrono::seconds(utils::yaml::findOrDefault<int>( + configYAML, "bufferFlushInterval", 0)); + const auto logSpans = + utils::yaml::findOrDefault<bool>(configYAML, "logSpans", false); + const auto localAgentHostPort = utils::yaml::findOrDefault<std::string>( + configYAML, "localAgentHostPort", ""); + const auto endpoint = utils::yaml::findOrDefault<std::string>( + configYAML, "endpoint", ""); + return Config( + queueSize, bufferFlushInterval, logSpans, localAgentHostPort, endpoint); + } + +#endif // JAEGERTRACING_WITH_YAML_CPP + + explicit Config( + int queueSize = kDefaultQueueSize, + const Clock::duration& bufferFlushInterval = + defaultBufferFlushInterval(), + bool logSpans = false, + const std::string& localAgentHostPort = kDefaultLocalAgentHostPort, const std::string& endpoint = kDefaultEndpoint) + : _queueSize(queueSize > 0 ? queueSize : kDefaultQueueSize) + , _bufferFlushInterval(bufferFlushInterval.count() > 0 + ? bufferFlushInterval + : defaultBufferFlushInterval()) + , _logSpans(logSpans) + , _localAgentHostPort(localAgentHostPort.empty() + ? kDefaultLocalAgentHostPort + : localAgentHostPort) + , _endpoint(endpoint) + { + } + + std::unique_ptr<Reporter> makeReporter(const std::string& serviceName, + logging::Logger& logger, + metrics::Metrics& metrics) const; + + int queueSize() const { return _queueSize; } + + const Clock::duration& bufferFlushInterval() const + { + return _bufferFlushInterval; + } + + bool logSpans() const { return _logSpans; } + + const std::string& localAgentHostPort() const + { + return _localAgentHostPort; + } + + const std::string& endpoint() const + { + return _endpoint; + } + + void fromEnv(); + + private: + int _queueSize; + Clock::duration _bufferFlushInterval; + bool _logSpans; + std::string _localAgentHostPort; + std::string _endpoint; +}; + +} // namespace reporters +} // namespace jaegertracing + +#endif // JAEGERTRACING_REPORTERS_CONFIG_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/ConfigTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/ConfigTest.cpp new file mode 100644 index 000000000..763177919 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/ConfigTest.cpp @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2019, The Jaeger Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <gtest/gtest.h> + +#include <string> + +#include <yaml-cpp/yaml.h> + +#include "jaegertracing/reporters/Config.h" + +namespace jaegertracing { +namespace reporters { + +TEST(Config, testLoadConfig) +{ + std::string yamlConfig = + "disabled: false\n" + "reporter:\n" + " logSpans: true\n" + " bufferFlushInterval: 88\n" + " localAgentHostPort: ahost:22\n" + " endpoint: http://somehost:33/api/traces\n" + "sampler:\n" + " type: const\n" + " param: 1"; + + auto configYAML = YAML::Load(yamlConfig); + auto reporterYAML = configYAML["reporter"]; + auto config = jaegertracing::reporters::Config::parse(reporterYAML); + + ASSERT_EQ(true, config.logSpans()); + ASSERT_EQ(std::chrono::seconds(88), config.bufferFlushInterval()); + ASSERT_EQ(std::string("ahost:22"), config.localAgentHostPort()); + ASSERT_EQ(std::string("http://somehost:33/api/traces"), config.endpoint()); +} + +} // namespace reporters +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/InMemoryReporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/InMemoryReporter.cpp new file mode 100644 index 000000000..dbba9cb2b --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/InMemoryReporter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/reporters/InMemoryReporter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/InMemoryReporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/InMemoryReporter.h new file mode 100644 index 000000000..7977ed450 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/InMemoryReporter.h @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_REPORTERS_INMEMORYREPORTER_H +#define JAEGERTRACING_REPORTERS_INMEMORYREPORTER_H + +#include <mutex> +#include <vector> + +#include "jaegertracing/Span.h" +#include "jaegertracing/reporters/Reporter.h" + +namespace jaegertracing { +namespace reporters { + +class InMemoryReporter : public Reporter { + public: + InMemoryReporter() + : _spans() + , _mutex() + { + constexpr auto kInitialCapacity = 10; + _spans.reserve(kInitialCapacity); + } + + void report(const Span& span) noexcept override + { + std::lock_guard<std::mutex> lock(_mutex); + _spans.push_back(span); + } + + void close() noexcept override {} + + int spansSubmitted() const noexcept + { + std::lock_guard<std::mutex> lock(_mutex); + return _spans.size(); + } + + std::vector<Span> spans() const noexcept + { + std::lock_guard<std::mutex> lock(_mutex); + return _spans; + } + + void reset() noexcept + { + std::lock_guard<std::mutex> lock(_mutex); + _spans.clear(); + } + + private: + std::vector<Span> _spans; + mutable std::mutex _mutex; +}; + +} // namespace reporters +} // namespace jaegertracing + +#endif // JAEGERTRACING_REPORTERS_INMEMORYREPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/LoggingReporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/LoggingReporter.cpp new file mode 100644 index 000000000..03a737454 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/LoggingReporter.cpp @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/reporters/LoggingReporter.h" +#include "jaegertracing/Logging.h" +#include "jaegertracing/Span.h" +#include <sstream> + +namespace jaegertracing { +namespace reporters { + +void LoggingReporter::report(const Span& span) noexcept +{ + std::ostringstream oss; + oss << "Reporting span " << span; + _logger.info(oss.str()); +} + +} // namespace reporters +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/LoggingReporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/LoggingReporter.h new file mode 100644 index 000000000..e13d56d46 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/LoggingReporter.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_REPORTERS_LOGGINGREPORTER_H +#define JAEGERTRACING_REPORTERS_LOGGINGREPORTER_H + +#include "jaegertracing/Logging.h" +#include "jaegertracing/reporters/Reporter.h" + +namespace jaegertracing { +namespace reporters { + +class LoggingReporter : public Reporter { + public: + explicit LoggingReporter(logging::Logger& logger) + : _logger(logger) + { + } + + void report(const Span& span) noexcept override; + + void close() noexcept override {} + + private: + logging::Logger& _logger; +}; + +} // namespace reporters +} // namespace jaegertracing + +#endif // JAEGERTRACING_REPORTERS_LOGGINGREPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/NullReporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/NullReporter.cpp new file mode 100644 index 000000000..2cb201b79 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/NullReporter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/reporters/NullReporter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/NullReporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/NullReporter.h new file mode 100644 index 000000000..87460f656 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/NullReporter.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_REPORTERS_NULLREPORTER_H +#define JAEGERTRACING_REPORTERS_NULLREPORTER_H + +#include "jaegertracing/reporters/Reporter.h" + +namespace jaegertracing { +class Span; +} // namespace jaegertracing + +namespace jaegertracing { +namespace reporters { + +class NullReporter : public Reporter { + public: + void report(const Span&) noexcept override {} + + void close() noexcept override {} +}; + +} // namespace reporters +} // namespace jaegertracing + +#endif // JAEGERTRACING_REPORTERS_NULLREPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/RemoteReporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/RemoteReporter.cpp new file mode 100644 index 000000000..d8378df56 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/RemoteReporter.cpp @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/reporters/RemoteReporter.h" + +#include <iostream> +#include <sstream> + +#include "jaegertracing/utils/ErrorUtil.h" + +namespace jaegertracing { +namespace reporters { + +RemoteReporter::RemoteReporter(const Clock::duration& bufferFlushInterval, + int fixedQueueSize, + std::unique_ptr<Sender>&& sender, + logging::Logger& logger, + metrics::Metrics& metrics) + : _bufferFlushInterval(bufferFlushInterval) + , _fixedQueueSize(fixedQueueSize) + , _sender(std::move(sender)) + , _logger(logger) + , _metrics(metrics) + , _queue() + , _queueLength(0) + , _running(true) + , _lastFlush(Clock::now()) + , _cv() + , _mutex() + , _thread() +{ + _thread = std::thread([this]() { sweepQueue(); }); +} + +void RemoteReporter::report(const Span& span) noexcept +{ + std::unique_lock<std::mutex> lock(_mutex); + const auto pushed = (static_cast<int>(_queue.size()) < _fixedQueueSize); + if (pushed) { + _queue.push_back(span); + lock.unlock(); + _cv.notify_one(); + ++_queueLength; + } + else { + _metrics.reporterDropped().inc(1); + } +} + +void RemoteReporter::close() noexcept +{ + try { + { + std::lock_guard<std::mutex> lock(_mutex); + if (!_running) { + return; + } + _running = false; + } + _cv.notify_one(); + _thread.join(); + flush(); + } catch (...) { + utils::ErrorUtil::logError(_logger, "Failed in Reporter::close"); + } +} + +void RemoteReporter::sweepQueue() noexcept +{ + while (true) { + try { + std::unique_lock<std::mutex> lock(_mutex); + _cv.wait_until(lock, _lastFlush + _bufferFlushInterval, [this]() { + return !_running || !_queue.empty(); + }); + + if (!_running && _queue.empty()) { + return; + } + + if (!_queue.empty()) { + const auto span = _queue.front(); + _queue.pop_front(); + --_queueLength; + sendSpan(span); + } + else if (bufferFlushIntervalExpired()) { + flush(); + } + } catch (...) { + utils::ErrorUtil::logError(_logger, + "Failed in Reporter::sweepQueue"); + } + } +} + +void RemoteReporter::sendSpan(const Span& span) noexcept +{ + try { + const auto flushed = _sender->append(span); + if (flushed > 0) { + _metrics.reporterSuccess().inc(flushed); + _metrics.reporterQueueLength().update(_queueLength); + } + } catch (const Sender::Exception& ex) { + _metrics.reporterFailure().inc(ex.numFailed()); + std::ostringstream oss; + oss << "error reporting span " << span.operationName() << ": " + << ex.what(); + _logger.error(oss.str()); + } +} + +void RemoteReporter::flush() noexcept +{ + try { + const auto flushed = _sender->flush(); + if (flushed > 0) { + _metrics.reporterSuccess().inc(flushed); + } + } catch (const Sender::Exception& ex) { + _metrics.reporterFailure().inc(ex.numFailed()); + _logger.error(ex.what()); + } + + _lastFlush = Clock::now(); +} + +} // namespace reporters +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/RemoteReporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/RemoteReporter.h new file mode 100644 index 000000000..e8648970f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/RemoteReporter.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_REPORTERS_REMOTEREPORTER_H +#define JAEGERTRACING_REPORTERS_REMOTEREPORTER_H + +#include <atomic> +#include <condition_variable> +#include <deque> +#include <mutex> +#include <thread> + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/Logging.h" +#include "jaegertracing/Span.h" +#include "jaegertracing/Sender.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/reporters/Reporter.h" + +namespace jaegertracing { +namespace reporters { + +class RemoteReporter : public Reporter { + public: + using Clock = std::chrono::steady_clock; + + RemoteReporter(const Clock::duration& bufferFlushInterval, + int fixedQueueSize, + std::unique_ptr<Sender>&& sender, + logging::Logger& logger, + metrics::Metrics& metrics); + + ~RemoteReporter() { close(); } + + void report(const Span& span) noexcept override; + + void close() noexcept override; + + private: + void sweepQueue() noexcept; + + void sendSpan(const Span& span) noexcept; + + void flush() noexcept; + + bool bufferFlushIntervalExpired() const + { + return (Clock::now() - _lastFlush) >= _bufferFlushInterval; + } + + Clock::duration _bufferFlushInterval; + int _fixedQueueSize; + std::unique_ptr<Sender> _sender; + logging::Logger& _logger; + metrics::Metrics& _metrics; + std::deque<Span> _queue; + std::atomic<int> _queueLength; + bool _running; + Clock::time_point _lastFlush; + std::condition_variable _cv; + std::mutex _mutex; + std::thread _thread; +}; + +} // namespace reporters +} // namespace jaegertracing + +#endif // JAEGERTRACING_REPORTERS_REMOTEREPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Reporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Reporter.cpp new file mode 100644 index 000000000..81cdbe821 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Reporter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/reporters/Reporter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Reporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Reporter.h new file mode 100644 index 000000000..cd8a64fb0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/Reporter.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_REPORTERS_REPORTER_H +#define JAEGERTRACING_REPORTERS_REPORTER_H + +#include "jaegertracing/Compilers.h" + +namespace jaegertracing { + +class Span; + +namespace reporters { + +class Reporter { + public: + virtual ~Reporter() = default; + + virtual void report(const Span& span) noexcept = 0; + + virtual void close() noexcept = 0; +}; + +} // namespace reporters +} // namespace jaegertracing + +#endif // JAEGERTRACING_REPORTERS_REPORTER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/ReporterTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/ReporterTest.cpp new file mode 100644 index 000000000..1c5552462 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/reporters/ReporterTest.cpp @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <gtest/gtest.h> + +#include "jaegertracing/Logging.h" +#include "jaegertracing/Tracer.h" +#include "jaegertracing/Sender.h" +#include "jaegertracing/reporters/CompositeReporter.h" +#include "jaegertracing/reporters/InMemoryReporter.h" +#include "jaegertracing/reporters/LoggingReporter.h" +#include "jaegertracing/reporters/NullReporter.h" +#include "jaegertracing/reporters/RemoteReporter.h" +#include "jaegertracing/samplers/ConstSampler.h" + +namespace jaegertracing { +namespace reporters { +namespace { + +class FakeTransport : public Sender { + public: + FakeTransport(std::vector<Span>& spans, std::mutex& mutex) + : _spans(spans) + , _mutex(mutex) + { + } + + int append(const Span& span) override + { + std::lock_guard<std::mutex> lock(_mutex); + _spans.push_back(span); + return 1; + } + + int flush() override { return 0; } + + void close() override {} + + private: + std::vector<Span>& _spans; + std::mutex& _mutex; +}; + +const Span span; + +} // anonymous namespace + +TEST(Reporter, testRemoteReporter) +{ + std::vector<Span> spans; + std::mutex mutex; + auto logger = logging::nullLogger(); + auto metrics = metrics::Metrics::makeNullMetrics(); + constexpr auto kFixedQueueSize = 10; + RemoteReporter reporter( + std::chrono::milliseconds(1), + kFixedQueueSize, + std::unique_ptr<Sender>(new FakeTransport(spans, mutex)), + *logger, + *metrics); + constexpr auto kNumReports = 100; + for (auto i = 0; i < kNumReports; ++i) { + reporter.report(span); + // TODO(isaachier): Find a way to make this test more rigorous. + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + reporter.close(); + ASSERT_EQ(spans.size(), kNumReports); +} + +TEST(Reporter, testNullReporter) +{ + NullReporter reporter; + constexpr auto kNumReports = 100; + for (auto i = 0; i < kNumReports; ++i) { + reporter.report(span); + } + reporter.close(); +} + +TEST(Reporter, testLoggingReporter) +{ + const auto logger = logging::nullLogger(); + LoggingReporter reporter(*logger); + constexpr auto kNumReports = 100; + for (auto i = 0; i < kNumReports; ++i) { + reporter.report(span); + } + reporter.close(); +} + +TEST(Reporter, testInMemoryReporter) +{ + InMemoryReporter reporter; + constexpr auto kNumReports = 100; + for (auto i = 0; i < kNumReports; ++i) { + reporter.report(span); + } + ASSERT_EQ(kNumReports, reporter.spansSubmitted()); + reporter.reset(); + ASSERT_EQ(0, reporter.spansSubmitted()); + reporter.close(); +} + +TEST(Reporter, testCompositeReporter) +{ + std::vector<std::shared_ptr<Reporter>> reporters; + reporters.push_back(std::make_shared<InMemoryReporter>()); + reporters.push_back(std::make_shared<InMemoryReporter>()); + + CompositeReporter reporter(reporters); + reporter.report(span); + ASSERT_EQ(1, + std::static_pointer_cast<InMemoryReporter>(reporters[0]) + ->spansSubmitted()); + ASSERT_EQ(1, + std::static_pointer_cast<InMemoryReporter>(reporters[1]) + ->spansSubmitted()); +} + +} // namespace reporters +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/AdaptiveSampler.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/AdaptiveSampler.cpp new file mode 100644 index 000000000..5468215b5 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/AdaptiveSampler.cpp @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/AdaptiveSampler.h" +#include "jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.h" +#include "jaegertracing/thrift-gen/sampling_types.h" +#include <cassert> +#include <iterator> +#include <memory> +#include <utility> + +namespace jaegertracing { +class TraceID; +} // namespace jaegertracing + +namespace jaegertracing { +namespace samplers { +namespace { + +AdaptiveSampler::SamplerMap samplersFromStrategies( + const sampling_manager::thrift::PerOperationSamplingStrategies& strategies) +{ + AdaptiveSampler::SamplerMap samplers; + for (auto&& strategy : strategies.perOperationStrategies) { + samplers[strategy.operation] = + std::make_shared<GuaranteedThroughputProbabilisticSampler>( + strategies.defaultLowerBoundTracesPerSecond, + strategy.probabilisticSampling.samplingRate); + } + return samplers; +} + +} // anonymous namespace + +AdaptiveSampler::AdaptiveSampler( + const sampling_manager::thrift::PerOperationSamplingStrategies& strategies, + size_t maxOperations) + : _samplers(samplersFromStrategies(strategies)) + , _defaultSampler(strategies.defaultSamplingProbability) + , _lowerBound(strategies.defaultLowerBoundTracesPerSecond) + , _maxOperations(maxOperations) + , _mutex() +{ +} + +SamplingStatus AdaptiveSampler::isSampled(const TraceID& id, + const std::string& operation) +{ + std::lock_guard<std::mutex> lock(_mutex); + auto samplerItr = _samplers.find(operation); + if (samplerItr != std::end(_samplers)) { + return samplerItr->second->isSampled(id, operation); + } + if (_samplers.size() >= _maxOperations) { + return _defaultSampler.isSampled(id, operation); + } + + auto newSampler = + std::make_shared<GuaranteedThroughputProbabilisticSampler>( + _lowerBound, _defaultSampler.samplingRate()); + _samplers[operation] = newSampler; + return newSampler->isSampled(id, operation); +} + +void AdaptiveSampler::close() +{ + std::lock_guard<std::mutex> lock(_mutex); + for (auto&& pair : _samplers) { + pair.second->close(); + } +} + +void AdaptiveSampler::update(const PerOperationSamplingStrategies& strategies) +{ + const auto lowerBound = strategies.defaultLowerBoundTracesPerSecond; + std::lock_guard<std::mutex> lock(_mutex); + for (auto&& strategy : strategies.perOperationStrategies) { + auto& sampler = _samplers[strategy.operation]; + const auto samplingRate = strategy.probabilisticSampling.samplingRate; + if (sampler) { + sampler->update(lowerBound, samplingRate); + } + else { + sampler = + std::make_shared<GuaranteedThroughputProbabilisticSampler>( + lowerBound, samplingRate); + } + assert(sampler); + } +} + +} // namespace samplers +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/AdaptiveSampler.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/AdaptiveSampler.h new file mode 100644 index 000000000..72154c8a6 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/AdaptiveSampler.h @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_ADAPTIVESAMPLER_H +#define JAEGERTRACING_SAMPLERS_ADAPTIVESAMPLER_H + +#include <mutex> +#include <string> +#include <unordered_map> + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/Constants.h" +#include "jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.h" +#include "jaegertracing/samplers/ProbabilisticSampler.h" +#include "jaegertracing/samplers/Sampler.h" + +namespace jaegertracing { +namespace sampling_manager { +namespace thrift { +class PerOperationSamplingStrategies; +} +} // namespace sampling_manager + +namespace samplers { + +class AdaptiveSampler : public Sampler { + public: + using PerOperationSamplingStrategies = + sampling_manager::thrift::PerOperationSamplingStrategies; + using SamplerMap = std::unordered_map< + std::string, + std::shared_ptr<GuaranteedThroughputProbabilisticSampler>>; + + AdaptiveSampler(const PerOperationSamplingStrategies& strategies, + size_t maxOperations); + + ~AdaptiveSampler() { close(); } + + SamplingStatus isSampled(const TraceID& id, + const std::string& operation) override; + + void close() override; + + void update(const PerOperationSamplingStrategies& strategies); + + Type type() const override { return Type::kAdaptiveSampler; } + + private: + SamplerMap _samplers; + ProbabilisticSampler _defaultSampler; + double _lowerBound; + size_t _maxOperations; + std::mutex _mutex; +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_ADAPTIVESAMPLER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Config.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Config.cpp new file mode 100644 index 000000000..75f1549b9 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Config.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/Config.h" +#include "jaegertracing/utils/EnvVariable.h" + +namespace jaegertracing { +namespace samplers { + +constexpr double Config::kDefaultSamplingProbability; +constexpr const char* Config::kDefaultSamplingServerURL; + +constexpr const char* Config::kJAEGER_SAMPLER_TYPE_ENV_PROP; +constexpr const char* Config::kJAEGER_SAMPLER_PARAM_ENV_PROP; + +void Config::fromEnv() +{ + const auto samplerType = utils::EnvVariable::getStringVariable(kJAEGER_SAMPLER_TYPE_ENV_PROP); + if (!samplerType.empty()) { + _type = samplerType; + } + + const auto param = utils::EnvVariable::getStringVariable(kJAEGER_SAMPLER_PARAM_ENV_PROP); + if (!param.empty()) { + std::istringstream iss(param); + double paramVal = 0; + if (iss >> paramVal) { + _param = paramVal; + } + } + const auto samplingServerURL = utils::EnvVariable::getStringVariable(kJAEGER_SAMPLING_ENDPOINT_ENV_PROP); + if (!samplingServerURL.empty()) { + _samplingServerURL = samplingServerURL; + } +} + +} // namespace samplers +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Config.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Config.h new file mode 100644 index 000000000..210feed95 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Config.h @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_CONFIG_H +#define JAEGERTRACING_SAMPLERS_CONFIG_H + +#include <cctype> +#include <chrono> +#include <memory> +#include <sstream> +#include <string> + +#include "jaegertracing/Constants.h" +#include "jaegertracing/Logging.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/samplers/ConstSampler.h" +#include "jaegertracing/samplers/ProbabilisticSampler.h" +#include "jaegertracing/samplers/RateLimitingSampler.h" +#include "jaegertracing/samplers/RemotelyControlledSampler.h" +#include "jaegertracing/samplers/Sampler.h" +#include "jaegertracing/utils/YAML.h" + +namespace jaegertracing { +namespace samplers { + +class Config { + public: + using Clock = std::chrono::steady_clock; + + static constexpr auto kDefaultSamplingProbability = + static_cast<double>(0.001); + static constexpr auto kDefaultSamplingServerURL = "http://127.0.0.1:5778/sampling"; + static constexpr auto kDefaultMaxOperations = 2000; + + static constexpr auto kJAEGER_SAMPLER_TYPE_ENV_PROP = "JAEGER_SAMPLER_TYPE"; + static constexpr auto kJAEGER_SAMPLER_PARAM_ENV_PROP = "JAEGER_SAMPLER_PARAM"; + static constexpr auto kJAEGER_SAMPLING_ENDPOINT_ENV_PROP = "JAEGER_SAMPLING_ENDPOINT"; + + static Clock::duration defaultSamplingRefreshInterval() + { + return std::chrono::minutes(1); + } + +#ifdef JAEGERTRACING_WITH_YAML_CPP + + static Config parse(const YAML::Node& configYAML) + { + if (!configYAML.IsDefined() || !configYAML.IsMap()) { + return Config(); + } + + const auto type = + utils::yaml::findOrDefault<std::string>(configYAML, "type", ""); + const auto param = + utils::yaml::findOrDefault<double>(configYAML, "param", -1); + const auto samplingServerURL = utils::yaml::findOrDefault<std::string>( + configYAML, "samplingServerURL", ""); + const auto maxOperations = + utils::yaml::findOrDefault<int>(configYAML, "maxOperations", 0); + const auto samplingRefreshInterval = + std::chrono::seconds(utils::yaml::findOrDefault<int>( + configYAML, "samplingRefreshInterval", 0)); + return Config(type, + param, + samplingServerURL, + maxOperations, + samplingRefreshInterval); + } + +#endif // JAEGERTRACING_WITH_YAML_CPP + + explicit Config( + const std::string& type = kSamplerTypeRemote, + double param = kDefaultSamplingProbability, + const std::string& samplingServerURL = kDefaultSamplingServerURL, + int maxOperations = kDefaultMaxOperations, + const Clock::duration& samplingRefreshInterval = + defaultSamplingRefreshInterval()) + : _type(type.empty() ? kSamplerTypeRemote : type) + , _param(param == -1 ? kDefaultSamplingProbability : param) + , _samplingServerURL(samplingServerURL.empty() + ? kDefaultSamplingServerURL + : samplingServerURL) + , _maxOperations(maxOperations == 0 ? kDefaultMaxOperations + : maxOperations) + , _samplingRefreshInterval(samplingRefreshInterval.count() > 0 + ? samplingRefreshInterval + : defaultSamplingRefreshInterval()) + { + } + + std::unique_ptr<Sampler> makeSampler(const std::string& serviceName, + logging::Logger& logger, + metrics::Metrics& metrics) const + { + std::string samplerType; + samplerType.reserve(_type.size()); + std::transform(std::begin(_type), + std::end(_type), + std::back_inserter(samplerType), + [](const char ch) { return std::tolower(ch); }); + if (samplerType == kSamplerTypeConst) { + return std::unique_ptr<ConstSampler>(new ConstSampler(_param != 0)); + } + + if (samplerType == kSamplerTypeProbabilistic) { + if (_param >= 0 && _param <= 1) { + return std::unique_ptr<ProbabilisticSampler>( + new ProbabilisticSampler(_param)); + } + else { + std::ostringstream oss; + oss << "Invalid parameter for probabilistic sampler: " << _param + << ", expecting value between 0 and 1"; + logger.error(oss.str()); + throw std::invalid_argument("Probabilistic sampling rate should be in the interval [0, 1]."); + return std::unique_ptr<Sampler>(); + } + } + + if (samplerType == kSamplerTypeRateLimiting) { + return std::unique_ptr<RateLimitingSampler>( + new RateLimitingSampler(_param)); + } + + if (samplerType == kSamplerTypeRemote || samplerType.empty()) { + auto config = *this; + config._type = kSamplerTypeProbabilistic; + std::shared_ptr<Sampler> initSampler( + config.makeSampler(serviceName, logger, metrics)); + if (!initSampler) { + return std::unique_ptr<Sampler>(); + } + + return std::unique_ptr<RemotelyControlledSampler>( + new RemotelyControlledSampler(serviceName, + _samplingServerURL, + initSampler, + _maxOperations, + _samplingRefreshInterval, + logger, + metrics)); + } + + std::ostringstream oss; + oss << "Unknown sampler type " << _type; + logger.error(oss.str()); + return std::unique_ptr<Sampler>(); + } + + const std::string& type() const { return _type; } + + double param() const { return _param; } + + const std::string& samplingServerURL() const { return _samplingServerURL; } + + int maxOperations() const { return _maxOperations; } + + const Clock::duration& samplingRefreshInterval() const + { + return _samplingRefreshInterval; + } + + void fromEnv(); + + private: + std::string _type; + double _param; + std::string _samplingServerURL; + int _maxOperations; + Clock::duration _samplingRefreshInterval; +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_CONFIG_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ConstSampler.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ConstSampler.cpp new file mode 100644 index 000000000..a9ae6572c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ConstSampler.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/ConstSampler.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ConstSampler.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ConstSampler.h new file mode 100644 index 000000000..ffd80f198 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ConstSampler.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_CONSTSAMPLER_H +#define JAEGERTRACING_SAMPLERS_CONSTSAMPLER_H + +#include "jaegertracing/Constants.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/samplers/Sampler.h" +#include "jaegertracing/samplers/SamplingStatus.h" +#include <string> +#include <vector> + +namespace jaegertracing { +class TraceID; +} // namespace jaegertracing + +namespace jaegertracing { +namespace samplers { + +class ConstSampler : public Sampler { + public: + explicit ConstSampler(bool sample) + : _decision(sample) + , _tags({ { kSamplerTypeTagKey, kSamplerTypeConst }, + { kSamplerParamTagKey, _decision } }) + { + } + + SamplingStatus isSampled(const TraceID& id, + const std::string& operation) override + { + return SamplingStatus(_decision, _tags); + } + + void close() override {} + + Type type() const override { return Type::kConstSampler; } + + private: + bool _decision; + std::vector<Tag> _tags; +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_CONSTSAMPLER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.cpp new file mode 100644 index 000000000..d58459dc5 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.h" + +namespace jaegertracing { +namespace samplers { + +void GuaranteedThroughputProbabilisticSampler::update(double lowerBound, + double samplingRate) +{ + if (_samplingRate != samplingRate) { + _probabilisticSampler = ProbabilisticSampler(samplingRate); + _samplingRate = _probabilisticSampler.samplingRate(); + _tags = { { kSamplerTypeTagKey, kSamplerTypeLowerBound }, + { kSamplerParamTagKey, _samplingRate } }; + } + + if (_lowerBound != lowerBound) { + _lowerBoundSampler.reset(new RateLimitingSampler(lowerBound)); + _lowerBound = lowerBound; + } +} + +} // namespace samplers +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.h new file mode 100644 index 000000000..a618b307e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.h @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_GUARANTEEDTHROUGHPUTPROBABILISTICSAMPLER_H +#define JAEGERTRACING_SAMPLERS_GUARANTEEDTHROUGHPUTPROBABILISTICSAMPLER_H + +#include "jaegertracing/Compilers.h" +#include "jaegertracing/Constants.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/samplers/ProbabilisticSampler.h" +#include "jaegertracing/samplers/RateLimitingSampler.h" +#include "jaegertracing/samplers/Sampler.h" +#include "jaegertracing/samplers/SamplingStatus.h" +#include <memory> +#include <string> +#include <vector> + +namespace jaegertracing { +class TraceID; +} // namespace jaegertracing + +namespace jaegertracing { +namespace samplers { + +class GuaranteedThroughputProbabilisticSampler : public Sampler +{ + public: + GuaranteedThroughputProbabilisticSampler(double lowerBound, + double samplingRate) + : _probabilisticSampler(samplingRate) + , _samplingRate(_probabilisticSampler.samplingRate()) + , _lowerBoundSampler(new RateLimitingSampler(lowerBound)) + , _lowerBound(lowerBound) + , _tags({ { kSamplerTypeTagKey, kSamplerTypeLowerBound }, + { kSamplerParamTagKey, _samplingRate } }) + { + } + + SamplingStatus isSampled(const TraceID& id, + const std::string& operation) override + { + const auto samplingStatus = + _probabilisticSampler.isSampled(id, operation); + if (samplingStatus.isSampled()) { + _lowerBoundSampler->isSampled(id, operation); + return samplingStatus; + } + const auto sampled = + _lowerBoundSampler->isSampled(id, operation).isSampled(); + return SamplingStatus(sampled, _tags); + } + + void close() override + { + _probabilisticSampler.close(); + _lowerBoundSampler->close(); + } + + void update(double lowerBound, double samplingRate); + + double lowerBound() const { return _lowerBound; } + + double samplingRate() const { return _samplingRate; } + + Type type() const override + { + return Type::kGuaranteedThroughputProbabilisticSampler; + } + + private: + ProbabilisticSampler _probabilisticSampler; + double _samplingRate; + std::unique_ptr<RateLimitingSampler> _lowerBoundSampler; + double _lowerBound; + std::vector<Tag> _tags; +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_GUARANTEEDTHROUGHPUTPROBABILISTICSAMPLER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ProbabilisticSampler.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ProbabilisticSampler.cpp new file mode 100644 index 000000000..c8b472b64 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ProbabilisticSampler.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/ProbabilisticSampler.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ProbabilisticSampler.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ProbabilisticSampler.h new file mode 100644 index 000000000..ab22c8206 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/ProbabilisticSampler.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_PROBABILISTICSAMPLER_H +#define JAEGERTRACING_SAMPLERS_PROBABILISTICSAMPLER_H + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/Constants.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/TraceID.h" +#include "jaegertracing/samplers/Sampler.h" +#include "jaegertracing/samplers/SamplingStatus.h" +#include <algorithm> +#include <cstdint> +#include <limits> +#include <string> +#include <vector> + +namespace jaegertracing { +namespace samplers { + +class ProbabilisticSampler : public Sampler { + public: + explicit ProbabilisticSampler(double samplingRate) + : _samplingRate(std::max(0.0, std::min(samplingRate, 1.0))) + , _samplingBoundary(computeSamplingBoundary(_samplingRate)) + , _tags({ { kSamplerTypeTagKey, kSamplerTypeProbabilistic }, + { kSamplerParamTagKey, _samplingRate } }) + { + } + + double samplingRate() const { return _samplingRate; } + + SamplingStatus isSampled(const TraceID& id, + const std::string& operation) override + { + return SamplingStatus(_samplingBoundary >= id.low(), _tags); + } + + void close() override {} + + Type type() const override { return Type::kProbabilisticSampler; } + + private: + static constexpr auto kMaxRandomNumber = + std::numeric_limits<uint64_t>::max(); + + double _samplingRate; + uint64_t _samplingBoundary; + std::vector<Tag> _tags; + + static uint64_t computeSamplingBoundary(long double samplingRate) + { + const auto maxRandNumber = static_cast<long double>(kMaxRandomNumber); + const auto samplingBoundary = samplingRate * maxRandNumber; + + // Protect against overflow in case samplingBoundary rounds + // higher than kMaxRandNumber. + if (samplingBoundary == maxRandNumber) { + return kMaxRandomNumber; + } + + return static_cast<uint64_t>(samplingBoundary); + } +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_PROBABILISTICSAMPLER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RateLimitingSampler.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RateLimitingSampler.cpp new file mode 100644 index 000000000..f1f9f2d62 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RateLimitingSampler.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/RateLimitingSampler.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RateLimitingSampler.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RateLimitingSampler.h new file mode 100644 index 000000000..c164ae176 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RateLimitingSampler.h @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_RATELIMITINGSAMPLER_H +#define JAEGERTRACING_SAMPLERS_RATELIMITINGSAMPLER_H + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/Constants.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/samplers/Sampler.h" +#include "jaegertracing/samplers/SamplingStatus.h" +#include "jaegertracing/utils/RateLimiter.h" +#include <algorithm> +#include <string> +#include <vector> + +namespace jaegertracing { +class TraceID; +} // namespace jaegertracing + +namespace jaegertracing { +namespace samplers { + +class RateLimitingSampler : public Sampler { + public: + explicit RateLimitingSampler(double maxTracesPerSecond) + : _maxTracesPerSecond(maxTracesPerSecond) + , _rateLimiter(_maxTracesPerSecond, std::max(_maxTracesPerSecond, 1.0)) + , _tags({ { kSamplerTypeTagKey, kSamplerTypeRateLimiting }, + { kSamplerParamTagKey, maxTracesPerSecond } }) + { + } + + SamplingStatus isSampled(const TraceID& id, + const std::string& operation) override + { + return SamplingStatus(_rateLimiter.checkCredit(1), _tags); + } + + void close() override {} + + Type type() const override { return Type::kRateLimitingSampler; } + + private: + double _maxTracesPerSecond; + utils::RateLimiter<> _rateLimiter; + std::vector<Tag> _tags; +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_RATELIMITINGSAMPLER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemoteSamplingJSON.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemoteSamplingJSON.cpp new file mode 100644 index 000000000..8925ed6ae --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemoteSamplingJSON.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/RemoteSamplingJSON.h"
\ No newline at end of file diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemoteSamplingJSON.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemoteSamplingJSON.h new file mode 100644 index 000000000..2f5872310 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemoteSamplingJSON.h @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_REMOTESAMPLINGJSON_H +#define JAEGERTRACING_SAMPLERS_REMOTESAMPLINGJSON_H + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/thrift-gen/sampling_types.h" +#include <cstdint> +#include <iterator> +#include <map> +#include <nlohmann/json.hpp> +#include <sstream> +#include <stdexcept> +#include <string> +#include <vector> + +namespace jaegertracing { +namespace sampling_manager { +namespace thrift { + +const std::map<int, const char*>& samplingStrategyType_VALUES_TO_NAMES(); + +#define JSON_FROM_FIELD(var, field) \ + { \ + json[#field] = var.field; \ + } + +#define FIELD_FROM_JSON(var, field) \ + { \ + var.__set_##field(json.at(#field)); \ + } + +inline void to_json(nlohmann::json& json, + const SamplingStrategyType::type& type) +{ + json = samplingStrategyType_VALUES_TO_NAMES().at(static_cast<int>(type)); +} + +inline void from_json(const nlohmann::json& json, + SamplingStrategyType::type& type) +{ + const auto str = json.get<std::string>(); + if (str == "PROBABILISTIC") { + type = SamplingStrategyType::PROBABILISTIC; + return; + } + if (str == "RATE_LIMITING") { + type = SamplingStrategyType::RATE_LIMITING; + return; + } + std::ostringstream oss; + oss << "Invalid sampling strategy type " << str; + throw std::invalid_argument(oss.str()); +} + +inline void to_json(nlohmann::json& json, + const ProbabilisticSamplingStrategy& strategy) +{ + JSON_FROM_FIELD(strategy, samplingRate); +} + +inline void from_json(const nlohmann::json& json, + ProbabilisticSamplingStrategy& strategy) +{ + FIELD_FROM_JSON(strategy, samplingRate); +} + +inline void to_json(nlohmann::json& json, + const RateLimitingSamplingStrategy& strategy) +{ + JSON_FROM_FIELD(strategy, maxTracesPerSecond); +} + +inline void from_json(const nlohmann::json& json, + RateLimitingSamplingStrategy& strategy) +{ + FIELD_FROM_JSON(strategy, maxTracesPerSecond); +} + +inline void to_json(nlohmann::json& json, + const OperationSamplingStrategy& strategy) +{ + JSON_FROM_FIELD(strategy, operation); + JSON_FROM_FIELD(strategy, probabilisticSampling); +} + +inline void from_json(const nlohmann::json& json, + OperationSamplingStrategy& strategy) +{ + FIELD_FROM_JSON(strategy, operation); + FIELD_FROM_JSON(strategy, probabilisticSampling); +} + +inline void to_json(nlohmann::json& json, + const PerOperationSamplingStrategies& strategies) +{ + JSON_FROM_FIELD(strategies, defaultSamplingProbability); + JSON_FROM_FIELD(strategies, defaultLowerBoundTracesPerSecond); + JSON_FROM_FIELD(strategies, perOperationStrategies); + if (strategies.__isset.defaultUpperBoundTracesPerSecond) { + JSON_FROM_FIELD(strategies, defaultUpperBoundTracesPerSecond); + } +} + +inline void from_json(const nlohmann::json& json, + PerOperationSamplingStrategies& strategies) +{ + FIELD_FROM_JSON(strategies, defaultSamplingProbability); + FIELD_FROM_JSON(strategies, defaultLowerBoundTracesPerSecond); + FIELD_FROM_JSON(strategies, perOperationStrategies); + auto itr = json.find("defaultUpperBoundTracesPerSecond"); + if (itr != std::end(json)) { + strategies.__set_defaultUpperBoundTracesPerSecond(itr->get<double>()); + } +} + +inline void to_json(nlohmann::json& json, + const SamplingStrategyResponse& response) +{ + JSON_FROM_FIELD(response, strategyType); + if (response.__isset.probabilisticSampling) { + JSON_FROM_FIELD(response, probabilisticSampling); + } + if (response.__isset.rateLimitingSampling) { + JSON_FROM_FIELD(response, rateLimitingSampling); + } + if (response.__isset.operationSampling) { + JSON_FROM_FIELD(response, operationSampling); + } +} + +inline void from_json(const nlohmann::json& json, + SamplingStrategyResponse& response) +{ + FIELD_FROM_JSON(response, strategyType); + auto itr = json.find("probabilisticSampling"); + if (itr != std::end(json)) { + response.__set_probabilisticSampling( + itr->get<ProbabilisticSamplingStrategy>()); + } + itr = json.find("rateLimitingSampling"); + if (itr != std::end(json)) { + response.__set_rateLimitingSampling( + itr->get<RateLimitingSamplingStrategy>()); + } + itr = json.find("operationSampling"); + if (itr != std::end(json)) { + response.__set_operationSampling( + itr->get<PerOperationSamplingStrategies>()); + } +} + +#undef FIELD_FROM_JSON +#undef JSON_FROM_FIELD + +} // namespace thrift +} // namespace sampling_manager +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_REMOTESAMPLINGJSON_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemotelyControlledSampler.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemotelyControlledSampler.cpp new file mode 100644 index 000000000..544ff9046 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemotelyControlledSampler.cpp @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/RemotelyControlledSampler.h" + +#include <cassert> +#include <sstream> + +#include "jaegertracing/metrics/Counter.h" +#include "jaegertracing/metrics/Gauge.h" +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/net/Socket.h" +#include "jaegertracing/net/URI.h" +#include "jaegertracing/net/http/Response.h" +#include "jaegertracing/samplers/AdaptiveSampler.h" +#include "jaegertracing/samplers/RemoteSamplingJSON.h" +#include "jaegertracing/thrift-gen/SamplingManager.h" +#include "jaegertracing/utils/ErrorUtil.h" + +namespace jaegertracing { +namespace samplers { +namespace { + +class HTTPSamplingManager : public sampling_manager::thrift::SamplingManagerIf { + public: + using SamplingStrategyResponse = + sampling_manager::thrift::SamplingStrategyResponse; + + HTTPSamplingManager(const std::string& serverURL, logging::Logger& logger) + : _serverURI(net::URI::parse(serverURL)) + , _logger(logger) + { + try { + net::Socket socket; + socket.open(AF_INET, SOCK_STREAM); + _serverAddr = socket.connect(serverURL); + } catch (...) { + utils::ErrorUtil::logError(_logger, "cannot connect to socket"); + } + } + + void getSamplingStrategy(SamplingStrategyResponse& result, + const std::string& serviceName) override + { + if (_serverAddr == net::IPAddress()) { + return; + } + auto uri = _serverURI; + uri._query = "service=" + net::URI::queryEscape(serviceName); + const auto responseHTTP = net::http::get(uri); + if (responseHTTP.statusCode() != 200) { + std::ostringstream oss; + oss << "Received HTTP error response" + ", uri=" + << uri << ", statusCode=" << responseHTTP.statusCode() + << ", reason=" << responseHTTP.reason(); + _logger.error(oss.str()); + return; + } + + result = nlohmann::json::parse(responseHTTP.body()); + } + + private: + net::URI _serverURI; + net::IPAddress _serverAddr; + logging::Logger& _logger; +}; + +} // anonymous namespace + +RemotelyControlledSampler::RemotelyControlledSampler( + const std::string& serviceName, + const std::string& samplingServerURL, + const std::shared_ptr<Sampler>& sampler, + int maxOperations, + const Clock::duration& samplingRefreshInterval, + logging::Logger& logger, + metrics::Metrics& metrics) + : _serviceName(serviceName) + , _samplingServerURL(samplingServerURL) + , _sampler(sampler) + , _maxOperations(maxOperations) + , _samplingRefreshInterval(samplingRefreshInterval) + , _logger(logger) + , _metrics(metrics) + , _manager( + std::make_shared<HTTPSamplingManager>(_samplingServerURL, _logger)) + , _running(true) + , _mutex() + , _shutdownCV() + , _thread([this]() { pollController(); }) +{ + assert(_sampler); +} + +SamplingStatus +RemotelyControlledSampler::isSampled(const TraceID& id, + const std::string& operation) +{ + std::lock_guard<std::mutex> lock(_mutex); + assert(_sampler); + return _sampler->isSampled(id, operation); +} + +void RemotelyControlledSampler::close() +{ + { + std::unique_lock<std::mutex> lock(_mutex); + if (!_running) { + return; + } + _running = false; + lock.unlock(); + _shutdownCV.notify_one(); + } + _thread.join(); +} + +void RemotelyControlledSampler::pollController() +{ + while (_running) { + updateSampler(); + std::unique_lock<std::mutex> lock(_mutex); + _shutdownCV.wait_for( + lock, _samplingRefreshInterval, [this]() { return !_running; }); + } +} + +void RemotelyControlledSampler::updateSampler() +{ + assert(_manager); + sampling_manager::thrift::SamplingStrategyResponse response; + try { + assert(_manager); + _manager->getSamplingStrategy(response, _serviceName); + } catch (const std::exception& ex) { + _metrics.samplerQueryFailure().inc(1); + return; + } catch (...) { + _metrics.samplerQueryFailure().inc(1); + return; + } + + std::lock_guard<std::mutex> lock(_mutex); + _metrics.samplerRetrieved().inc(1); + + if (response.__isset.operationSampling) { + updateAdaptiveSampler(response.operationSampling); + } + else { + try { + updateRateLimitingOrProbabilisticSampler(response); + } catch (const std::exception& ex) { + _metrics.samplerUpdateFailure().inc(1); + return; + } catch (...) { + _metrics.samplerUpdateFailure().inc(1); + return; + } + } + _metrics.samplerUpdated().inc(1); +} + +void RemotelyControlledSampler::updateAdaptiveSampler( + const PerOperationSamplingStrategies& strategies) +{ + auto sampler = _sampler; + assert(sampler); + if (sampler->type() == Type::kAdaptiveSampler) { + static_cast<AdaptiveSampler&>(*sampler).update(strategies); + } + else { + _sampler = + std::make_shared<AdaptiveSampler>(strategies, _maxOperations); + } +} + +void RemotelyControlledSampler::updateRateLimitingOrProbabilisticSampler( + const SamplingStrategyResponse& response) +{ + std::shared_ptr<Sampler> sampler; + if (response.__isset.probabilisticSampling) { + sampler = std::make_shared<ProbabilisticSampler>( + response.probabilisticSampling.samplingRate); + } + else if (response.__isset.rateLimitingSampling) { + sampler = std::make_shared<RateLimitingSampler>( + response.rateLimitingSampling.maxTracesPerSecond); + } + else { + std::ostringstream oss; + oss << "Unsupported sampling strategy type " << response.strategyType; + throw std::runtime_error(oss.str()); + } + _sampler = sampler; +} + +} // namespace samplers +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemotelyControlledSampler.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemotelyControlledSampler.h new file mode 100644 index 000000000..8f1d50bd8 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/RemotelyControlledSampler.h @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_REMOTELYCONTROLLEDSAMPLER_H +#define JAEGERTRACING_SAMPLERS_REMOTELYCONTROLLEDSAMPLER_H + +#include <chrono> +#include <condition_variable> +#include <mutex> +#include <thread> + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/Constants.h" +#include "jaegertracing/Logging.h" +#include "jaegertracing/metrics/Metrics.h" +#include "jaegertracing/samplers/ProbabilisticSampler.h" +#include "jaegertracing/samplers/Sampler.h" + +namespace jaegertracing { + +namespace sampling_manager { +namespace thrift { +class PerOperationSamplingStrategies; +class SamplingStrategyResponse; +class SamplingManagerIf; +} // namespace thrift +} // namespace sampling_manager + +namespace samplers { + +class RemotelyControlledSampler : public Sampler { + public: + using Clock = std::chrono::steady_clock; + + RemotelyControlledSampler(const std::string& serviceName, + const std::string& samplingServerURL, + const std::shared_ptr<Sampler>& sampler, + int maxOperations, + const Clock::duration& samplingRefreshInterval, + logging::Logger& logger, + metrics::Metrics& metrics); + + ~RemotelyControlledSampler() { close(); } + + SamplingStatus isSampled(const TraceID& id, + const std::string& operation) override; + + void close() override; + + Type type() const override { return Type::kRemotelyControlledSampler; } + + private: + using PerOperationSamplingStrategies = + sampling_manager::thrift::PerOperationSamplingStrategies; + using SamplingStrategyResponse = + sampling_manager::thrift::SamplingStrategyResponse; + + void pollController(); + + void updateSampler(); + + void + updateAdaptiveSampler(const PerOperationSamplingStrategies& strategies); + + void updateRateLimitingOrProbabilisticSampler( + const SamplingStrategyResponse& response); + + std::string _serviceName; + std::string _samplingServerURL; + std::shared_ptr<Sampler> _sampler; + int _maxOperations; + Clock::duration _samplingRefreshInterval; + logging::Logger& _logger; + metrics::Metrics& _metrics; + std::shared_ptr<sampling_manager::thrift::SamplingManagerIf> _manager; + bool _running; + std::mutex _mutex; + std::condition_variable _shutdownCV; + std::thread _thread; +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_REMOTELYCONTROLLEDSAMPLER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Sampler.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Sampler.cpp new file mode 100644 index 000000000..9ce93618d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Sampler.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/Sampler.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Sampler.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Sampler.h new file mode 100644 index 000000000..61375c8c2 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/Sampler.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_SAMPLER_H +#define JAEGERTRACING_SAMPLERS_SAMPLER_H + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/TraceID.h" +#include "jaegertracing/samplers/SamplingStatus.h" + +namespace jaegertracing { +namespace samplers { + +class Sampler { + public: + enum class Type { + kAdaptiveSampler, + kConstSampler, + kGuaranteedThroughputProbabilisticSampler, + kProbabilisticSampler, + kRateLimitingSampler, + kRemotelyControlledSampler + }; + + virtual ~Sampler() = default; + + virtual SamplingStatus isSampled(const TraceID& id, + const std::string& operation) = 0; + + virtual void close() = 0; + + virtual Type type() const = 0; +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_SAMPLER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplerTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplerTest.cpp new file mode 100644 index 000000000..3c082d322 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplerTest.cpp @@ -0,0 +1,372 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <random> + +#include <gtest/gtest.h> + +#include "jaegertracing/Constants.h" +#include "jaegertracing/Tag.h" +#include "jaegertracing/samplers/AdaptiveSampler.h" +#include "jaegertracing/samplers/Config.h" +#include "jaegertracing/samplers/ConstSampler.h" +#include "jaegertracing/samplers/GuaranteedThroughputProbabilisticSampler.h" +#include "jaegertracing/samplers/ProbabilisticSampler.h" +#include "jaegertracing/samplers/RateLimitingSampler.h" +#include "jaegertracing/samplers/RemotelyControlledSampler.h" +#include "jaegertracing/samplers/Sampler.h" +#include "jaegertracing/samplers/SamplingStatus.h" +#include "jaegertracing/testutils/MockAgent.h" +#include "jaegertracing/testutils/TUDPTransport.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" + +namespace jaegertracing { +namespace samplers { +namespace { + +constexpr auto kTestOperationName = "op"; +constexpr auto kTestFirstTimeOperationName = "firstTimeOp"; +constexpr auto kTestDefaultSamplingProbability = 0.5; +constexpr auto kTestMaxID = std::numeric_limits<uint64_t>::max() / 2 + 1; +constexpr auto kTestDefaultMaxOperations = 10; + +const Tag testProbablisticExpectedTags[] = { + { "sampler.type", "probabilistic" }, { "sampler.param", 0.5 } +}; + +const Tag testLowerBoundExpectedTags[] = { { "sampler.type", "lowerbound" }, + { "sampler.param", 0.5 } }; + +#define CMP_TAGS(tagArr, tagVec) \ + { \ + ASSERT_EQ(sizeof(tagArr) / sizeof(Tag), (tagVec).size()); \ + for (auto i = static_cast<size_t>(0); i < (tagVec).size(); ++i) { \ + jaegertracing::thrift::Tag thriftTagArr; \ + jaegertracing::thrift::Tag thriftTagVec; \ + (tagArr)[i].thrift(thriftTagArr); \ + (tagVec)[i].thrift(thriftTagVec); \ + ASSERT_EQ(thriftTagArr, thriftTagVec); \ + } \ + } + +} // anonymous namespace + +TEST(Sampler, testSamplerTags) +{ + ConstSampler constTrue(true); + ConstSampler constFalse(false); + ProbabilisticSampler prob(0.1); + RateLimitingSampler rate(0.1); + + const struct { + Sampler& _sampler; + std::string _samplerType; + Tag::ValueType _samplerParam; + } tests[] = { { constTrue, "const", true }, + { constFalse, "const", false }, + { prob, "probabilistic", 0.1 }, + { rate, "ratelimiting", 0.1 } }; + + for (auto&& test : tests) { + const auto tags = + test._sampler.isSampled(TraceID(), kTestOperationName).tags(); + auto count = 0; + for (auto&& tag : tags) { + if (tag.key() == kSamplerTypeTagKey) { + ASSERT_TRUE(tag.value().is<const char*>()); + ASSERT_EQ(test._samplerType, tag.value().get<const char*>()); + ++count; + } + else if (tag.key() == kSamplerParamTagKey) { + ASSERT_EQ(test._samplerParam, tag.value()); + ++count; + } + } + ASSERT_EQ(2, count); + } +} + +TEST(Sampler, testProbabilisticSamplerErrors) +{ + ProbabilisticSampler sampler(-0.1); + ASSERT_LE(0, sampler.samplingRate()); + ASSERT_GE(1, sampler.samplingRate()); + sampler = ProbabilisticSampler(1.1); + ASSERT_LE(0, sampler.samplingRate()); + ASSERT_GE(1, sampler.samplingRate()); +} + +TEST(Sampler, testProbabilisticSampler) +{ + { + ProbabilisticSampler sampler(0.5); + auto result = + sampler.isSampled(TraceID(0, kTestMaxID + 10), kTestOperationName); + ASSERT_FALSE(result.isSampled()); + CMP_TAGS(testProbablisticExpectedTags, result.tags()); + + result = + sampler.isSampled(TraceID(0, kTestMaxID - 20), kTestOperationName); + ASSERT_TRUE(result.isSampled()); + CMP_TAGS(testProbablisticExpectedTags, result.tags()); + } + { + ProbabilisticSampler sampler(1.0); + auto result = + sampler.isSampled(TraceID(0, kTestMaxID), kTestOperationName); + ASSERT_TRUE(result.isSampled()); + + result = + sampler.isSampled(TraceID(0, kTestMaxID - 20), kTestOperationName); + ASSERT_TRUE(result.isSampled()); + } +} + +TEST(Sampler, testProbabilisticSamplerPerformance) +{ + constexpr auto kNumSamples = static_cast<uint64_t>(10000); + + ProbabilisticSampler sampler(0.001); + std::random_device randomDevice; + std::default_random_engine randomGenerator(randomDevice()); + std::uniform_int_distribution<uint64_t> distribution; + auto count = static_cast<uint64_t>(0); + for (auto i = static_cast<uint64_t>(0); i < kNumSamples; ++i) { + TraceID id(0, distribution(randomGenerator)); + if (sampler.isSampled(id, kTestOperationName).isSampled()) { + ++count; + } + } + const auto rate = static_cast<double>(count) / kNumSamples; + std::cout << "Sampled: " << count << " rate=" << rate << '\n'; +} + +TEST(Sampler, testProbabilisticSamplerInvalidRate) +{ + Config samplerConfig1(kSamplerTypeProbabilistic, + 1.1, + "", + 0, + samplers::Config::Clock::duration()); + Config samplerConfig2(kSamplerTypeProbabilistic, + -0.1, + "", + 0, + samplers::Config::Clock::duration()); + auto logger = logging::nullLogger(); + auto metrics = metrics::Metrics::makeNullMetrics(); + ASSERT_THROW(samplerConfig1.makeSampler("test-service", *logger, *metrics), + std::invalid_argument); + ASSERT_THROW(samplerConfig2.makeSampler("test-service", *logger, *metrics), + std::invalid_argument); +} + +TEST(Sampler, testRateLimitingSampler) +{ + { + RateLimitingSampler sampler(2); + auto result = sampler.isSampled(TraceID(), kTestOperationName); + ASSERT_TRUE(result.isSampled()); + result = sampler.isSampled(TraceID(), kTestOperationName); + ASSERT_TRUE(result.isSampled()); + result = sampler.isSampled(TraceID(), kTestOperationName); + ASSERT_FALSE(result.isSampled()); + } + + { + RateLimitingSampler sampler(0.1); + auto result = sampler.isSampled(TraceID(), kTestOperationName); + ASSERT_TRUE(result.isSampled()); + result = sampler.isSampled(TraceID(), kTestOperationName); + ASSERT_FALSE(result.isSampled()); + } +} + +TEST(Sampler, testGuaranteedThroughputProbabilisticSamplerUpdate) +{ + auto lowerBound = 2.0; + auto samplingRate = 0.5; + GuaranteedThroughputProbabilisticSampler sampler(lowerBound, samplingRate); + ASSERT_EQ(lowerBound, sampler.lowerBound()); + ASSERT_EQ(samplingRate, sampler.samplingRate()); + + auto newLowerBound = 1.0; + auto newSamplingRate = 0.6; + sampler.update(newLowerBound, newSamplingRate); + ASSERT_EQ(newLowerBound, sampler.lowerBound()); + ASSERT_EQ(newSamplingRate, sampler.samplingRate()); + + newSamplingRate = 1.1; + sampler.update(newLowerBound, newSamplingRate); + ASSERT_EQ(1.0, sampler.samplingRate()); +} + +TEST(Sampler, testAdaptiveSampler) +{ + namespace thriftgen = sampling_manager::thrift; + + thriftgen::OperationSamplingStrategy strategy; + strategy.__set_operation(kTestOperationName); + thriftgen::ProbabilisticSamplingStrategy probabilisticSampling; + probabilisticSampling.__set_samplingRate(kTestDefaultSamplingProbability); + strategy.__set_probabilisticSampling(probabilisticSampling); + + thriftgen::PerOperationSamplingStrategies strategies; + strategies.__set_defaultSamplingProbability( + kTestDefaultSamplingProbability); + strategies.__set_defaultLowerBoundTracesPerSecond(1.0); + strategies.__set_perOperationStrategies({ strategy }); + + AdaptiveSampler sampler(strategies, kTestDefaultMaxOperations); + auto result = + sampler.isSampled(TraceID(0, kTestMaxID + 10), kTestOperationName); + ASSERT_TRUE(result.isSampled()); + CMP_TAGS(testLowerBoundExpectedTags, result.tags()); + + result = sampler.isSampled(TraceID(0, kTestMaxID - 20), kTestOperationName); + ASSERT_TRUE(result.isSampled()); + CMP_TAGS(testProbablisticExpectedTags, result.tags()); + + result = sampler.isSampled(TraceID(0, kTestMaxID + 10), kTestOperationName); + ASSERT_FALSE(result.isSampled()); + + result = sampler.isSampled(TraceID(0, kTestMaxID - 20), + kTestFirstTimeOperationName); + ASSERT_TRUE(result.isSampled()); + CMP_TAGS(testProbablisticExpectedTags, result.tags()); +} + +TEST(Sampler, testAdaptiveSamplerErrors) +{ + namespace thriftgen = sampling_manager::thrift; + + thriftgen::OperationSamplingStrategy strategy; + strategy.__set_operation(kTestOperationName); + thriftgen::ProbabilisticSamplingStrategy probabilisticSampling; + probabilisticSampling.__set_samplingRate(-0.1); + strategy.__set_probabilisticSampling(probabilisticSampling); + + thriftgen::PerOperationSamplingStrategies strategies; + strategies.__set_defaultSamplingProbability( + kTestDefaultSamplingProbability); + strategies.__set_defaultLowerBoundTracesPerSecond(2.0); + strategies.__set_perOperationStrategies({ strategy }); + + { + AdaptiveSampler sampler(strategies, kTestDefaultMaxOperations); + } + + { + strategies.perOperationStrategies.at(0) + .probabilisticSampling.__set_samplingRate(1.1); + AdaptiveSampler sampler(strategies, kTestDefaultMaxOperations); + } +} + +TEST(Sampler, testAdaptiveSamplerUpdate) +{ + namespace thriftgen = sampling_manager::thrift; + + constexpr auto kSamplingRate = 0.1; + constexpr auto kLowerBound = 2.0; + + thriftgen::OperationSamplingStrategy strategy; + strategy.__set_operation(kTestOperationName); + thriftgen::ProbabilisticSamplingStrategy probabilisticSampling; + probabilisticSampling.__set_samplingRate(kSamplingRate); + strategy.__set_probabilisticSampling(probabilisticSampling); + + thriftgen::PerOperationSamplingStrategies strategies; + strategies.__set_defaultSamplingProbability( + kTestDefaultSamplingProbability); + strategies.__set_defaultLowerBoundTracesPerSecond(kLowerBound); + strategies.__set_perOperationStrategies({ strategy }); + + AdaptiveSampler sampler(strategies, kTestDefaultMaxOperations); + + constexpr auto kNewSamplingRate = 0.2; + constexpr auto kNewLowerBound = 3.0; + constexpr auto kNewDefaultSamplingProbability = 0.1; + + // Updated kTestOperationName strategy. + thriftgen::OperationSamplingStrategy updatedStrategy; + updatedStrategy.__set_operation(kTestOperationName); + thriftgen::ProbabilisticSamplingStrategy updatedProbabilisticSampling; + updatedProbabilisticSampling.__set_samplingRate(kNewSamplingRate); + updatedStrategy.__set_probabilisticSampling(updatedProbabilisticSampling); + + // New kTestFirstTimeOperationName strategy. + thriftgen::OperationSamplingStrategy newStrategy; + newStrategy.__set_operation(kTestFirstTimeOperationName); + thriftgen::ProbabilisticSamplingStrategy newProbabilisticSampling; + newProbabilisticSampling.__set_samplingRate(kNewSamplingRate); + newStrategy.__set_probabilisticSampling(newProbabilisticSampling); + + thriftgen::PerOperationSamplingStrategies newStrategies; + newStrategies.__set_defaultSamplingProbability( + kNewDefaultSamplingProbability); + newStrategies.__set_defaultLowerBoundTracesPerSecond(kNewLowerBound); + newStrategies.__set_perOperationStrategies( + { updatedStrategy, newStrategy }); + + sampler.update(newStrategies); +} + +TEST(Sampler, testRemotelyControlledSampler) +{ + const auto mockAgent = testutils::MockAgent::make(); + mockAgent->start(); + const auto logger = logging::nullLogger(); + const auto metrics = metrics::Metrics::makeNullMetrics(); + + // Make sure remote sampling probability is 1 + sampling_manager::thrift::SamplingStrategyResponse config; + config.__set_strategyType( + sampling_manager::thrift::SamplingStrategyType::PROBABILISTIC); + sampling_manager::thrift::ProbabilisticSamplingStrategy probaStrategy; + probaStrategy.__set_samplingRate(1.0); + config.__set_probabilisticSampling(probaStrategy); + mockAgent->addSamplingStrategy("test-service", config); + + // Default probability of 0.5, switches to 1 when downloaded + RemotelyControlledSampler sampler( + "test-service", + "http://" + mockAgent->samplingServerAddress().authority(), + std::make_shared<ProbabilisticSampler>(kTestDefaultSamplingProbability), + kTestDefaultMaxOperations, + std::chrono::milliseconds(100), + *logger, + *metrics); + + // Wait a bit for remote config download to be done + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + std::random_device device; + std::mt19937_64 rng; + rng.seed(device()); + for (auto startTime = RemotelyControlledSampler::Clock::now(); + std::chrono::duration_cast<std::chrono::seconds>( + RemotelyControlledSampler::Clock::now() - startTime) + .count() < 1;) { + TraceID traceID(rng(), rng()); + // If probability was 0.5 we could reasonnably assume one of 50 samples fail + ASSERT_TRUE(sampler.isSampled(traceID, kTestOperationName).isSampled()); + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + } + sampler.close(); +} + +} // namespace samplers +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplingStatus.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplingStatus.cpp new file mode 100644 index 000000000..1dafffa9f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplingStatus.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/samplers/SamplingStatus.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplingStatus.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplingStatus.h new file mode 100644 index 000000000..a0ea3e4ed --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/samplers/SamplingStatus.h @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_SAMPLERS_SAMPLINGSTATUS_H +#define JAEGERTRACING_SAMPLERS_SAMPLINGSTATUS_H + +#include <vector> + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/Tag.h" + +namespace jaegertracing { +namespace samplers { + +class SamplingStatus { + public: + SamplingStatus(bool isSampled, const std::vector<Tag>& tags) + : _isSampled(isSampled) + , _tags(tags) + { + } + + bool isSampled() const { return _isSampled; } + + const std::vector<Tag>& tags() const { return _tags; } + + private: + bool _isSampled; + std::vector<Tag> _tags; +}; + +} // namespace samplers +} // namespace jaegertracing + +#endif // JAEGERTRACING_SAMPLERS_SAMPLINGSTATUS_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/EnvVariable.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/EnvVariable.cpp new file mode 100644 index 000000000..726bbb23f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/EnvVariable.cpp @@ -0,0 +1,17 @@ +/*
+ * Copyright (c) 2019 The Jaeger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "jaegertracing/testutils/EnvVariable.h"
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/EnvVariable.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/EnvVariable.h new file mode 100644 index 000000000..ec6121406 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/EnvVariable.h @@ -0,0 +1,38 @@ +/*
+ * Copyright (c) 2019 The Jaeger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JAEGERTRACING_TESTUTILS_ENVVARIABLE_H
+#define JAEGERTRACING_TESTUTILS_ENVVARIABLE_H
+
+#include <string>
+
+namespace jaegertracing {
+namespace testutils {
+namespace EnvVariable {
+
+inline void setEnv(const char *variable, const char *value) {
+#ifdef WIN32
+ _putenv_s(variable, value);
+#else
+ setenv(variable, value, true);
+#endif
+}
+
+} // namespace EnvVariable
+} // namespace testutils
+} // namespace jaegertracing
+
+#endif // JAEGERTRACING_TESTUTILS_ENVVARIABLE_H
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgent.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgent.cpp new file mode 100644 index 000000000..3af881b02 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgent.cpp @@ -0,0 +1,253 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/testutils/MockAgent.h" + +#include <regex> +#include <thread> + +#include <thrift/protocol/TCompactProtocol.h> +#include <thrift/transport/TBufferTransports.h> + +#include "jaegertracing/Logging.h" +#include "jaegertracing/baggage/RemoteRestrictionJSON.h" +#include "jaegertracing/net/http/Error.h" +#include "jaegertracing/net/http/Request.h" +#include "jaegertracing/net/http/Response.h" +#include "jaegertracing/samplers/RemoteSamplingJSON.h" +#include "jaegertracing/utils/ErrorUtil.h" +#include "jaegertracing/utils/UDPTransporter.h" + +#ifdef _MSC_VER +#pragma warning(disable : 4267) +#pragma warning(disable : 4244) +#endif + +namespace jaegertracing { +namespace testutils { +namespace { + +#ifdef WIN32 +#define READ_ERROR SOCKET_ERROR +#else +#define READ_ERROR -1 +#endif + +static size_t read(int socketHandle, char* buffer, size_t size) +{ + int returnValue = ::recv(socketHandle, buffer, size, 0); + return (returnValue == READ_ERROR) ? 0 : returnValue; +} + +bool startsWith(const std::string& str, const std::string& prefix) +{ + if (str.size() < prefix.size()) { + return false; + } + return std::equal(std::begin(prefix), std::end(prefix), std::begin(str)); +} + +} // anonymous namespace + +MockAgent::~MockAgent() { close(); } + +void MockAgent::start() +{ + std::promise<void> startedUDP; + std::promise<void> startedHTTP; + _udpThread = std::thread([this, &startedUDP]() { serveUDP(startedUDP); }); + _httpThread = + std::thread([this, &startedHTTP]() { serveHTTP(startedHTTP); }); + startedUDP.get_future().wait(); + startedHTTP.get_future().wait(); +} + +void MockAgent::close() +{ + if (_servingUDP) { + _servingUDP = false; + _transport.close(); + _udpThread.join(); + } + + if (_servingHTTP) { + _servingHTTP = false; + _httpThread.join(); + } +} + +void MockAgent::emitBatch(const thrift::Batch& batch) +{ + std::lock_guard<std::mutex> lock(_mutex); + _batches.push_back(batch); +} + +MockAgent::MockAgent() + : _transport(net::IPAddress::v4("127.0.0.1", 0)) + , _servingUDP(false) +{ +} + +void MockAgent::serveUDP(std::promise<void>& started) +{ + using TCompactProtocolFactory = + apache::thrift::protocol::TCompactProtocolFactory; + using TMemoryBuffer = apache::thrift::transport::TMemoryBuffer; + + auto iface = shared_from_this(); + agent::thrift::AgentProcessor handler(iface); + TCompactProtocolFactory protocolFactory; + std::shared_ptr<TMemoryBuffer> trans( + new TMemoryBuffer(utils::UDPTransporter::kUDPPacketMaxLength)); + + // Notify main thread that setup is done. + _servingUDP = true; + started.set_value(); + + std::array<uint8_t, utils::UDPTransporter::kUDPPacketMaxLength> buffer; + while (isServingUDP()) { + try { + const auto numRead = + _transport.read(&buffer[0], utils::UDPTransporter::kUDPPacketMaxLength); + if (numRead > 0) { + trans->write(&buffer[0], numRead); + auto protocol = protocolFactory.getProtocol(trans); + handler.process(protocol, protocol, nullptr); + } + } catch (...) { + auto logger = logging::consoleLogger(); + utils::ErrorUtil::logError( + *logger, "An error occurred in MockAgent::serveUDP"); + } + } +} + +void MockAgent::serveHTTP(std::promise<void>& started) +{ + net::Socket socket; + socket.open(AF_INET, SOCK_STREAM); + socket.bind(net::IPAddress::v4("127.0.0.1", 0)); + socket.listen(); + ::sockaddr_storage addrStorage; + ::socklen_t addrLen = sizeof(addrStorage); + const auto returnCode = ::getsockname( + socket.handle(), reinterpret_cast<sockaddr*>(&addrStorage), &addrLen); + if (returnCode != 0) { + throw std::system_error(errno, + std::generic_category(), + "Failed to get HTTP address from socket"); + } + _httpAddress = net::IPAddress(addrStorage, addrLen); + + _servingHTTP = true; + started.set_value(); + + const std::regex servicePattern("[?&]service=([^?&]+)"); + while (isServingHTTP()) { + constexpr auto kBufferSize = 256; + std::array<char, kBufferSize> buffer; + std::string requestStr; + auto clientSocket = socket.accept(); + auto numRead = read( + clientSocket.handle(), &buffer[0], buffer.size()); + while (numRead > 0) { + requestStr.append(&buffer[0], numRead); + if (numRead < static_cast<int>(buffer.size())) { + break; + } + numRead = read( + clientSocket.handle(), &buffer[0], buffer.size()); + } + + try { + enum class Resource { kSampler, kBaggage }; + + std::istringstream iss(requestStr); + const auto request = net::http::Request::parse(iss); + const auto target = request.target(); + + auto resource = Resource::kSampler; + if (startsWith(target, "/baggageRestrictions") || + startsWith(target, + _httpAddress.authority() + "/baggageRestrictions")) { + resource = Resource::kBaggage; + } + std::smatch match; + if (!std::regex_search(target, match, servicePattern)) { + throw net::http::ParseError("no 'service' parameter"); + } + if (std::regex_search(match.suffix().str(), servicePattern)) { + throw net::http::ParseError( + "'service' parameter must occur only once"); + } + const auto serviceName = match[1].str(); + + std::string responseJSON; + switch (resource) { + case Resource::kSampler: { + sampling_manager::thrift::SamplingStrategyResponse response; + _samplingMgr.getSamplingStrategy(response, serviceName); + responseJSON = nlohmann::json(response).dump(); + } break; + default: { + assert(resource == Resource::kBaggage); + thrift::BaggageRestrictionManager_getBaggageRestrictions_result + response; + std::vector<thrift::BaggageRestriction> restrictions; + restrictions.reserve(_restrictions.size()); + std::transform(std::begin(_restrictions), + std::end(_restrictions), + std::back_inserter(restrictions), + [](const KeyRestrictionMap::value_type& pair) { + thrift::BaggageRestriction restriction; + restriction.__set_baggageKey(pair.first); + restriction.__set_maxValueLength( + pair.second.maxValueLength()); + return restriction; + }); + response.success = std::move(restrictions); + response.__isset.success = true; + responseJSON = nlohmann::json(response).dump(); + } break; + } + std::ostringstream oss; + oss << "HTTP/1.1 200 OK\r\n" + "Content-Type: application/json\r\n\r\n" + << responseJSON; + const auto responseStr = oss.str(); + const auto numWritten = ::send( + clientSocket.handle(), responseStr.c_str(), responseStr.size(), 0); + (void)numWritten; + } catch (const net::http::ParseError& ex) { + std::ostringstream oss; + oss << "HTTP/1.1 400 Bad Request\r\n\r\n" << ex.what(); + const auto response = oss.str(); + const auto numWritten = ::send( + clientSocket.handle(), response.c_str(), response.size(), 0); + (void)numWritten; + } catch (const std::exception& ex) { + std::ostringstream oss; + oss << "HTTP/1.1 500 Internal Server Error\r\n\r\n" << ex.what(); + const auto response = oss.str(); + const auto numWritten = ::send( + clientSocket.handle(), response.c_str(), response.size(), 0); + (void)numWritten; + } + } +} + +} // namespace testutils +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgent.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgent.h new file mode 100644 index 000000000..6a761ada7 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgent.h @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_TESTUTILS_MOCKAGENT_H +#define JAEGERTRACING_TESTUTILS_MOCKAGENT_H + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/baggage/RemoteRestrictionManager.h" +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/testutils/SamplingManager.h" +#include "jaegertracing/testutils/TUDPTransport.h" +#include "jaegertracing/thrift-gen/Agent.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" +#include "jaegertracing/utils/UDPTransporter.h" +#include <atomic> +#include <future> +#include <memory> +#include <mutex> +#include <stdexcept> +#include <string> +#include <thread> +#include <type_traits> +#include <utility> +#include <vector> + +namespace jaegertracing { +namespace baggage { +class Restriction; +} // namespace baggage +} // namespace jaegertracing +namespace twitter { +namespace zipkin { +namespace thrift { +class Span; +} // namespace thrift +} // namespace zipkin +} // namespace twitter + +namespace jaegertracing { +namespace testutils { + +class MockAgent : public agent::thrift::AgentIf, + public std::enable_shared_from_this<MockAgent> { + public: + using KeyRestrictionMap = + baggage::RemoteRestrictionManager::KeyRestrictionMap; + + static std::shared_ptr<MockAgent> make() + { + // Avoid `make_shared` when `weak_ptr` might be used. + std::shared_ptr<MockAgent> newInstance(new MockAgent()); + return newInstance; + } + + ~MockAgent(); + + void start(); + + void close(); + + void + emitZipkinBatch(const std::vector<twitter::zipkin::thrift::Span>&) override + { + throw std::logic_error("emitZipkinBatch not implemented"); + } + + void emitBatch(const thrift::Batch& batch) override; + + bool isServingUDP() const { return _servingUDP; } + + bool isServingHTTP() const { return _servingHTTP; } + + template <typename... Args> + void addSamplingStrategy(Args&&... args) + { + _samplingMgr.addSamplingStrategy(std::forward<Args>(args)...); + } + + void addBaggageRestriction(const std::string& key, + const baggage::Restriction& restriction) + { + _restrictions.insert(std::make_pair(key, restriction)); + } + + std::vector<thrift::Batch> batches() const + { + std::lock_guard<std::mutex> lock(_mutex); + return _batches; + } + + net::IPAddress spanServerAddress() const { return _transport.addr(); } + + std::unique_ptr<utils::Transport> spanServerClient() + { + return std::unique_ptr<utils::Transport>( + new utils::UDPTransporter(spanServerAddress(), 0)); + } + + net::IPAddress samplingServerAddress() const { return _httpAddress; } + + void resetBatches() + { + std::lock_guard<std::mutex> lock(_mutex); + _batches.clear(); + } + + private: + MockAgent(); + + void serveUDP(std::promise<void>& started); + + void serveHTTP(std::promise<void>& started); + + TUDPTransport _transport; + std::vector<thrift::Batch> _batches; + std::atomic<bool> _servingUDP; + std::atomic<bool> _servingHTTP; + SamplingManager _samplingMgr; + KeyRestrictionMap _restrictions; + mutable std::mutex _mutex; + std::thread _udpThread; + std::thread _httpThread; + net::IPAddress _httpAddress; +}; + +} // namespace testutils +} // namespace jaegertracing + +#endif // JAEGERTRACING_TESTUTILS_MOCKAGENT_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgentTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgentTest.cpp new file mode 100644 index 000000000..a9b3d2981 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/MockAgentTest.cpp @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <sstream> + +#include <gtest/gtest.h> +#include <nlohmann/json.hpp> + +#include "jaegertracing/baggage/RemoteRestrictionJSON.h" +#include "jaegertracing/net/http/Response.h" +#include "jaegertracing/samplers/RemoteSamplingJSON.h" +#include "jaegertracing/testutils/MockAgent.h" + +namespace jaegertracing { +namespace testutils { + +TEST(MockAgent, testSpanServer) +{ + std::shared_ptr<MockAgent> mockAgent = MockAgent::make(); + mockAgent->start(); + + auto client = mockAgent->spanServerClient(); + + constexpr auto kBiggestBatch = 5; + for (auto i = 1; i < kBiggestBatch; ++i) { + thrift::Batch batch; + batch.spans.resize(i); + for (auto j = 0; j < i; ++j) { + std::string operationName("span-"); + operationName += std::to_string(j); + batch.spans[j].__set_operationName(operationName); + } + + client->emitBatch(batch); + + constexpr auto kNumTries = 100; + for (auto k = 0; k < kNumTries; ++k) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + const auto batches = mockAgent->batches(); + if (!batches.empty() && + static_cast<int>(batches[0].spans.size()) == i) { + break; + } + } + + const auto batches = mockAgent->batches(); + ASSERT_FALSE(batches.empty()); + ASSERT_EQ(i, static_cast<int>(batches[0].spans.size())); + for (auto j = 0; j < i; ++j) { + std::string operationName("span-"); + operationName += std::to_string(j); + ASSERT_EQ(operationName, batches[0].spans[j].operationName); + } + mockAgent->resetBatches(); + } +} + +TEST(MockAgent, testSamplingManager) +{ + auto mockAgent = MockAgent::make(); + mockAgent->start(); + + { + std::ostringstream oss; + oss << "http://" << mockAgent->samplingServerAddress().authority() + << '/'; + const auto uriStr = oss.str(); + const auto uri = net::URI::parse(uriStr); + const auto response = net::http::get(uri); + ASSERT_EQ("no 'service' parameter", response.body()); + } + { + std::ostringstream oss; + oss << "http://" << mockAgent->samplingServerAddress().authority() + << "/?service=a&service=b"; + const auto uriStr = oss.str(); + const auto uri = net::URI::parse(uriStr); + const auto response = net::http::get(uri); + ASSERT_EQ("'service' parameter must occur only once", response.body()); + } + { + std::ostringstream oss; + oss << "http://" << mockAgent->samplingServerAddress().authority() + << "/?service=something"; + const auto uriStr = oss.str(); + const auto uri = net::URI::parse(uriStr); + const auto responseHTTP = net::http::get(uri); + sampling_manager::thrift::SamplingStrategyResponse response; + response = nlohmann::json::parse(responseHTTP.body()); + ASSERT_EQ(sampling_manager::thrift::SamplingStrategyType::PROBABILISTIC, + response.strategyType); + } + { + sampling_manager::thrift::SamplingStrategyResponse config; + config.__set_strategyType( + sampling_manager::thrift::SamplingStrategyType::RATE_LIMITING); + sampling_manager::thrift::RateLimitingSamplingStrategy rateLimiting; + rateLimiting.__set_maxTracesPerSecond(123); + config.__set_rateLimitingSampling(rateLimiting); + mockAgent->addSamplingStrategy("service123", config); + + std::ostringstream oss; + oss << "http://" << mockAgent->samplingServerAddress().authority() + << "/?service=service123"; + const auto uriStr = oss.str(); + const auto uri = net::URI::parse(uriStr); + const auto responseHTTP = net::http::get(uri); + sampling_manager::thrift::SamplingStrategyResponse response; + response = nlohmann::json::parse(responseHTTP.body()); + ASSERT_EQ(config, response); + } +} + +} // namespace testutils +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/SamplingManager.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/SamplingManager.cpp new file mode 100644 index 000000000..ee6c53fed --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/SamplingManager.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/testutils/SamplingManager.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/SamplingManager.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/SamplingManager.h new file mode 100644 index 000000000..f1cca89d7 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/SamplingManager.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_TESTUTILS_SAMPLINGMANAGER_H +#define JAEGERTRACING_TESTUTILS_SAMPLINGMANAGER_H + +#include "jaegertracing/Compilers.h" + +#include "jaegertracing/thrift-gen/SamplingManager.h" +#include "jaegertracing/thrift-gen/sampling_types.h" +#include <iterator> +#include <mutex> +#include <string> +#include <unordered_map> +#include <utility> + +namespace jaegertracing { +namespace testutils { + +class SamplingManager : public sampling_manager::thrift::SamplingManagerIf { + public: + using Response = sampling_manager::thrift::SamplingStrategyResponse; + + void getSamplingStrategy(Response& response, + const std::string& service) override + { + using ProbabilisticSamplingStrategy = + sampling_manager::thrift::ProbabilisticSamplingStrategy; + using SamplingStrategyType = + sampling_manager::thrift::SamplingStrategyType; + + std::lock_guard<std::mutex> lock(_mutex); + auto responseItr = _sampling.find(service); + if (responseItr != std::end(_sampling)) { + response = responseItr->second; + return; + } + + constexpr auto kSamplingRate = 0.01; + ProbabilisticSamplingStrategy probabilisticSampling; + probabilisticSampling.__set_samplingRate(kSamplingRate); + response.__set_strategyType(SamplingStrategyType::PROBABILISTIC); + response.__set_probabilisticSampling(probabilisticSampling); + } + + void addSamplingStrategy(const std::string& serviceName, + const Response& response) + { + std::lock_guard<std::mutex> lock(_mutex); + _sampling[serviceName] = response; + } + + private: + using StrategyMap = std::unordered_map<std::string, Response>; + + StrategyMap _sampling; + std::mutex _mutex; +}; + +} // namespace testutils +} // namespace jaegertracing + +#endif // JAEGERTRACING_TESTUTILS_SAMPLINGMANAGER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransport.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransport.cpp new file mode 100644 index 000000000..275d1a444 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransport.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/testutils/TUDPTransport.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransport.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransport.h new file mode 100644 index 000000000..ceee2815c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransport.h @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_TESTUTILS_TUDPTRANSPORT_H +#define JAEGERTRACING_TESTUTILS_TUDPTRANSPORT_H + +#include "jaegertracing/Compilers.h" + +#ifdef WIN32 +#include <winsock2.h> +#else +#include <sys/socket.h> +#endif + +#include <thrift/transport/TVirtualTransport.h> + +#include "jaegertracing/utils/UDPTransporter.h" + +namespace jaegertracing { +namespace testutils { + +class TUDPTransport + : public apache::thrift::transport::TVirtualTransport<TUDPTransport> { + public: + explicit TUDPTransport(const net::IPAddress& addr) + : _socket() + , _serverAddr(addr) + { + _socket.open(AF_INET, SOCK_DGRAM); + _socket.bind(_serverAddr); + if (_serverAddr.port() == 0) { + ::sockaddr_storage addrStorage; + ::socklen_t addrLen = sizeof(addrStorage); + const auto returnCode = + ::getsockname(_socket.handle(), + reinterpret_cast<::sockaddr*>(&addrStorage), + &addrLen); + if (returnCode == 0) { + _serverAddr = net::IPAddress(addrStorage, addrLen); + } + } + } + + bool isOpen() override { return _socket.handle() >= 0; } + + void open() override {} + + void close() override { _socket.close(); } + + net::IPAddress addr() const { return _serverAddr; } + + uint32_t read(uint8_t* buf, uint32_t len) + { + ::sockaddr_storage clientAddr; + auto clientAddrLen = static_cast<::socklen_t>(sizeof(clientAddr)); + const auto numRead = + ::recvfrom(_socket.handle(), +#ifdef WIN32 + reinterpret_cast<char*>(buf), // this cast is safe +#else + buf, +#endif + len, + 0, + reinterpret_cast<::sockaddr*>(&clientAddr), + &clientAddrLen); + _clientAddr = net::IPAddress(clientAddr, clientAddrLen); + // the return value conrreponds to the size of the data read from the + // socket. upon error, recvfrom return -1. In this case, we return 0 to + // say that noothing was read. + return std::max<long>(0, numRead); + } + + void write(const uint8_t* buf, uint32_t len) + { + ::sendto(_socket.handle(), +#ifdef WIN32 + reinterpret_cast<const char*>(buf), // this cast is safe +#else + buf, +#endif + len, + 0, + reinterpret_cast<const ::sockaddr*>(&_clientAddr.addr()), + _clientAddr.addrLen()); + } + + private: + net::Socket _socket; + net::IPAddress _serverAddr; + net::IPAddress _clientAddr; + ::socklen_t _clientAddrLen; +}; + +} // namespace testutils +} // namespace jaegertracing + +#endif // JAEGERTRACING_TESTUTILS_TUDPTRANSPORT_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransportTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransportTest.cpp new file mode 100644 index 000000000..b0c87c1e7 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TUDPTransportTest.cpp @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/net/Socket.h" +#include "jaegertracing/testutils/TUDPTransport.h" +#include <array> +#include <cstdint> +#include <gtest/gtest.h> +#include <string> +#include <thread> + +#ifdef _MSC_VER +#pragma warning(disable : 4267) +#endif + +namespace jaegertracing { +namespace testutils { +namespace { + +constexpr auto kBufferSize = 256; + +} // anonymous namespace + +TEST(TUDPTransport, testUDPTransport) +{ + const std::string message("test"); + + TUDPTransport server(net::IPAddress::v4("127.0.0.1", 0)); + server.open(); // Not necessary. Just making sure this is called. + ASSERT_TRUE(server.isOpen()); + + const auto serverAddr = server.addr(); + std::thread clientThread([serverAddr, message]() { + net::Socket connUDP; + connUDP.open(AF_INET, SOCK_DGRAM); + const auto numWritten = + ::sendto(connUDP.handle(), + message.c_str(), + message.size(), + 0, + reinterpret_cast<const ::sockaddr*>(&serverAddr.addr()), + serverAddr.addrLen()); + ASSERT_EQ(numWritten, message.size()); + + std::array<char, kBufferSize> buffer; + const auto numRead = ::recvfrom( + connUDP.handle(), &buffer[0], buffer.size(), 0, nullptr, 0); + const std::string received(&buffer[0], &buffer[numRead]); + ASSERT_EQ(message.size(), numRead); + ASSERT_EQ(message, received); + + connUDP.close(); + }); + + std::array<uint8_t, kBufferSize> buffer; + const auto numRead = server.readAll(&buffer[0], message.size()); + ASSERT_LT(0, numRead); + server.write(&buffer[0], numRead); + + clientThread.join(); + server.close(); +} + +} // namespace testutils +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TracerUtil.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TracerUtil.cpp new file mode 100644 index 000000000..ffa65c1f5 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TracerUtil.cpp @@ -0,0 +1,82 @@ +/*
+ * Copyright (c) 2017 Uber Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "jaegertracing/testutils/TracerUtil.h"
+#include "jaegertracing/Config.h"
+#include "jaegertracing/Logging.h"
+#include "jaegertracing/Tracer.h"
+#include "jaegertracing/baggage/RestrictionsConfig.h"
+#include "jaegertracing/net/IPAddress.h"
+#include "jaegertracing/propagation/HeadersConfig.h"
+#include "jaegertracing/reporters/Config.h"
+#include "jaegertracing/samplers/Config.h"
+#include <memory>
+#include <ostream>
+#include <string>
+
+namespace jaegertracing {
+namespace testutils {
+namespace TracerUtil {
+
+std::shared_ptr<ResourceHandle> installGlobalTracer()
+{
+ std::unique_ptr<ResourceHandle> handle(new ResourceHandle());
+ handle->_mockAgent->start();
+ std::ostringstream samplingServerURLStream;
+ samplingServerURLStream
+ << "http://" << handle->_mockAgent->samplingServerAddress().authority();
+ Config config(
+ false,
+ samplers::Config("const",
+ 1,
+ samplingServerURLStream.str(),
+ 0,
+ samplers::Config::Clock::duration()),
+ reporters::Config(0,
+ reporters::Config::Clock::duration(),
+ false,
+ handle->_mockAgent->spanServerAddress().authority()),
+ propagation::HeadersConfig(),
+ baggage::RestrictionsConfig());
+
+ auto tracer = Tracer::make("test-service", config, logging::nullLogger());
+ opentracing::Tracer::InitGlobal(tracer);
+ return std::move(handle);
+}
+
+std::shared_ptr<opentracing::Tracer> buildTracer(const std::string& endpoint)
+{
+ std::ostringstream samplingServerURLStream;
+ Config config(
+ false,
+ samplers::Config("const",
+ 1,
+ samplingServerURLStream.str(),
+ 0,
+ samplers::Config::Clock::duration()),
+ reporters::Config(0,
+ std::chrono::milliseconds(100),
+ false, "", endpoint),
+ propagation::HeadersConfig(),
+ baggage::RestrictionsConfig());
+
+ auto tracer = Tracer::make("test-service", config, logging::nullLogger());
+ return tracer;
+}
+
+} // namespace TracerUtil
+} // namespace testutils
+} // namespace jaegertracing
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TracerUtil.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TracerUtil.h new file mode 100644 index 000000000..a61e57006 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/testutils/TracerUtil.h @@ -0,0 +1,50 @@ +/*
+ * Copyright (c) 2017 Uber Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JAEGERTRACING_TESTUTILS_TRACERUTIL_H
+#define JAEGERTRACING_TESTUTILS_TRACERUTIL_H
+
+#include <string>
+
+#include "jaegertracing/Tracer.h"
+#include "jaegertracing/testutils/MockAgent.h"
+
+namespace jaegertracing {
+namespace testutils {
+namespace TracerUtil {
+
+struct ResourceHandle {
+ ResourceHandle()
+ : _mockAgent(testutils::MockAgent::make())
+ {
+ }
+
+ ~ResourceHandle()
+ {
+ opentracing::Tracer::InitGlobal(opentracing::MakeNoopTracer());
+ }
+
+ std::shared_ptr<MockAgent> _mockAgent;
+};
+
+std::shared_ptr<ResourceHandle> installGlobalTracer();
+std::shared_ptr<opentracing::Tracer> buildTracer(const std::string& endpoint);
+
+} // namespace TracerUtil
+} // namespace testutils
+} // namespace jaegertracing
+
+#endif // JAEGERTRACING_TESTUTILS_TRACERUTIL_H
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Agent.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Agent.cpp new file mode 100644 index 000000000..db05c0004 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Agent.cpp @@ -0,0 +1,380 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "Agent.h" + +namespace jaegertracing { namespace agent { namespace thrift { + + +Agent_emitZipkinBatch_args::~Agent_emitZipkinBatch_args() throw() { +} + + +uint32_t Agent_emitZipkinBatch_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->spans.clear(); + uint32_t _size0; + ::apache::thrift::protocol::TType _etype3; + xfer += iprot->readListBegin(_etype3, _size0); + this->spans.resize(_size0); + uint32_t _i4; + for (_i4 = 0; _i4 < _size0; ++_i4) + { + xfer += this->spans[_i4].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.spans = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Agent_emitZipkinBatch_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Agent_emitZipkinBatch_args"); + + xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->spans.size())); + std::vector< ::twitter::zipkin::thrift::Span> ::const_iterator _iter5; + for (_iter5 = this->spans.begin(); _iter5 != this->spans.end(); ++_iter5) + { + xfer += (*_iter5).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Agent_emitZipkinBatch_pargs::~Agent_emitZipkinBatch_pargs() throw() { +} + + +uint32_t Agent_emitZipkinBatch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Agent_emitZipkinBatch_pargs"); + + xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->spans)).size())); + std::vector< ::twitter::zipkin::thrift::Span> ::const_iterator _iter6; + for (_iter6 = (*(this->spans)).begin(); _iter6 != (*(this->spans)).end(); ++_iter6) + { + xfer += (*_iter6).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Agent_emitBatch_args::~Agent_emitBatch_args() throw() { +} + + +uint32_t Agent_emitBatch_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->batch.read(iprot); + this->__isset.batch = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Agent_emitBatch_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Agent_emitBatch_args"); + + xfer += oprot->writeFieldBegin("batch", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->batch.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Agent_emitBatch_pargs::~Agent_emitBatch_pargs() throw() { +} + + +uint32_t Agent_emitBatch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Agent_emitBatch_pargs"); + + xfer += oprot->writeFieldBegin("batch", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->batch)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void AgentClient::emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) +{ + send_emitZipkinBatch(spans); +} + +void AgentClient::send_emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("emitZipkinBatch", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + Agent_emitZipkinBatch_pargs args; + args.spans = &spans; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AgentClient::emitBatch(const ::jaegertracing::thrift::Batch& batch) +{ + send_emitBatch(batch); +} + +void AgentClient::send_emitBatch(const ::jaegertracing::thrift::Batch& batch) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("emitBatch", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + Agent_emitBatch_pargs args; + args.batch = &batch; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool AgentProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void AgentProcessor::process_emitZipkinBatch(int32_t, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol*, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("Agent.emitZipkinBatch", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Agent.emitZipkinBatch"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "Agent.emitZipkinBatch"); + } + + Agent_emitZipkinBatch_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "Agent.emitZipkinBatch", bytes); + } + + try { + iface_->emitZipkinBatch(args.spans); + } catch (const std::exception&) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "Agent.emitZipkinBatch"); + } + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->asyncComplete(ctx, "Agent.emitZipkinBatch"); + } + + return; +} + +void AgentProcessor::process_emitBatch(int32_t, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol*, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("Agent.emitBatch", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Agent.emitBatch"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "Agent.emitBatch"); + } + + Agent_emitBatch_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "Agent.emitBatch", bytes); + } + + try { + iface_->emitBatch(args.batch); + } catch (const std::exception&) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "Agent.emitBatch"); + } + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->asyncComplete(ctx, "Agent.emitBatch"); + } + + return; +} + +::std::shared_ptr< ::apache::thrift::TProcessor > AgentProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< AgentIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< AgentIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new AgentProcessor(handler)); + return processor; +} + +void AgentConcurrentClient::emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) +{ + send_emitZipkinBatch(spans); +} + +void AgentConcurrentClient::send_emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) +{ + int32_t cseqid = 0; + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("emitZipkinBatch", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + Agent_emitZipkinBatch_pargs args; + args.spans = &spans; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); +} + +void AgentConcurrentClient::emitBatch(const ::jaegertracing::thrift::Batch& batch) +{ + send_emitBatch(batch); +} + +void AgentConcurrentClient::send_emitBatch(const ::jaegertracing::thrift::Batch& batch) +{ + int32_t cseqid = 0; + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("emitBatch", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + Agent_emitBatch_pargs args; + args.batch = &batch; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); +} + +}}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Agent.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Agent.h new file mode 100644 index 000000000..daa567896 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Agent.h @@ -0,0 +1,306 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef Agent_H +#define Agent_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "agent_types.h" + +namespace jaegertracing { namespace agent { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class AgentIf { + public: + virtual ~AgentIf() {} + virtual void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) = 0; + virtual void emitBatch(const ::jaegertracing::thrift::Batch& batch) = 0; +}; + +class AgentIfFactory { + public: + typedef AgentIf Handler; + + virtual ~AgentIfFactory() {} + + virtual AgentIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(AgentIf* /* handler */) = 0; +}; + +class AgentIfSingletonFactory : virtual public AgentIfFactory { + public: + AgentIfSingletonFactory(const ::std::shared_ptr<AgentIf>& iface) : iface_(iface) {} + virtual ~AgentIfSingletonFactory() {} + + virtual AgentIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(AgentIf* /* handler */) {} + + protected: + ::std::shared_ptr<AgentIf> iface_; +}; + +class AgentNull : virtual public AgentIf { + public: + virtual ~AgentNull() {} + void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & /* spans */) { + return; + } + void emitBatch(const ::jaegertracing::thrift::Batch& /* batch */) { + return; + } +}; + +typedef struct _Agent_emitZipkinBatch_args__isset { + _Agent_emitZipkinBatch_args__isset() : spans(false) {} + bool spans :1; +} _Agent_emitZipkinBatch_args__isset; + +class Agent_emitZipkinBatch_args { + public: + + Agent_emitZipkinBatch_args(const Agent_emitZipkinBatch_args&); + Agent_emitZipkinBatch_args& operator=(const Agent_emitZipkinBatch_args&); + Agent_emitZipkinBatch_args() { + } + + virtual ~Agent_emitZipkinBatch_args() throw(); + std::vector< ::twitter::zipkin::thrift::Span> spans; + + _Agent_emitZipkinBatch_args__isset __isset; + + void __set_spans(const std::vector< ::twitter::zipkin::thrift::Span> & val); + + bool operator == (const Agent_emitZipkinBatch_args & rhs) const + { + if (!(spans == rhs.spans)) + return false; + return true; + } + bool operator != (const Agent_emitZipkinBatch_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Agent_emitZipkinBatch_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class Agent_emitZipkinBatch_pargs { + public: + + + virtual ~Agent_emitZipkinBatch_pargs() throw(); + const std::vector< ::twitter::zipkin::thrift::Span> * spans; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _Agent_emitBatch_args__isset { + _Agent_emitBatch_args__isset() : batch(false) {} + bool batch :1; +} _Agent_emitBatch_args__isset; + +class Agent_emitBatch_args { + public: + + Agent_emitBatch_args(const Agent_emitBatch_args&); + Agent_emitBatch_args& operator=(const Agent_emitBatch_args&); + Agent_emitBatch_args() { + } + + virtual ~Agent_emitBatch_args() throw(); + ::jaegertracing::thrift::Batch batch; + + _Agent_emitBatch_args__isset __isset; + + void __set_batch(const ::jaegertracing::thrift::Batch& val); + + bool operator == (const Agent_emitBatch_args & rhs) const + { + if (!(batch == rhs.batch)) + return false; + return true; + } + bool operator != (const Agent_emitBatch_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Agent_emitBatch_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class Agent_emitBatch_pargs { + public: + + + virtual ~Agent_emitBatch_pargs() throw(); + const ::jaegertracing::thrift::Batch* batch; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +class AgentClient : virtual public AgentIf { + public: + AgentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + AgentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans); + void send_emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans); + void emitBatch(const ::jaegertracing::thrift::Batch& batch); + void send_emitBatch(const ::jaegertracing::thrift::Batch& batch); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class AgentProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<AgentIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (AgentProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_emitZipkinBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_emitBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + AgentProcessor(::std::shared_ptr<AgentIf> iface) : + iface_(iface) { + processMap_["emitZipkinBatch"] = &AgentProcessor::process_emitZipkinBatch; + processMap_["emitBatch"] = &AgentProcessor::process_emitBatch; + } + + virtual ~AgentProcessor() {} +}; + +class AgentProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + AgentProcessorFactory(const ::std::shared_ptr< AgentIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< AgentIfFactory > handlerFactory_; +}; + +class AgentMultiface : virtual public AgentIf { + public: + AgentMultiface(std::vector<std::shared_ptr<AgentIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~AgentMultiface() {} + protected: + std::vector<std::shared_ptr<AgentIf> > ifaces_; + AgentMultiface() {} + void add(::std::shared_ptr<AgentIf> iface) { + ifaces_.push_back(iface); + } + public: + void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->emitZipkinBatch(spans); + } + ifaces_[i]->emitZipkinBatch(spans); + } + + void emitBatch(const ::jaegertracing::thrift::Batch& batch) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->emitBatch(batch); + } + ifaces_[i]->emitBatch(batch); + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class AgentConcurrentClient : virtual public AgentIf { + public: + AgentConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + AgentConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans); + void send_emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans); + void emitBatch(const ::jaegertracing::thrift::Batch& batch); + void send_emitBatch(const ::jaegertracing::thrift::Batch& batch); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/AggregationValidator.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/AggregationValidator.cpp new file mode 100644 index 000000000..516ef9a28 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/AggregationValidator.cpp @@ -0,0 +1,424 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "AggregationValidator.h" + +namespace jaegertracing { namespace thrift { + + +AggregationValidator_validateTrace_args::~AggregationValidator_validateTrace_args() throw() { +} + + +uint32_t AggregationValidator_validateTrace_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_traceId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->traceId); + isset_traceId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_traceId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AggregationValidator_validateTrace_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AggregationValidator_validateTrace_args"); + + xfer += oprot->writeFieldBegin("traceId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->traceId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +AggregationValidator_validateTrace_pargs::~AggregationValidator_validateTrace_pargs() throw() { +} + + +uint32_t AggregationValidator_validateTrace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AggregationValidator_validateTrace_pargs"); + + xfer += oprot->writeFieldBegin("traceId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->traceId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +AggregationValidator_validateTrace_result::~AggregationValidator_validateTrace_result() throw() { +} + + +uint32_t AggregationValidator_validateTrace_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AggregationValidator_validateTrace_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("AggregationValidator_validateTrace_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +AggregationValidator_validateTrace_presult::~AggregationValidator_validateTrace_presult() throw() { +} + + +uint32_t AggregationValidator_validateTrace_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +void AggregationValidatorClient::validateTrace(ValidateTraceResponse& _return, const std::string& traceId) +{ + send_validateTrace(traceId); + recv_validateTrace(_return); +} + +void AggregationValidatorClient::send_validateTrace(const std::string& traceId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("validateTrace", ::apache::thrift::protocol::T_CALL, cseqid); + + AggregationValidator_validateTrace_pargs args; + args.traceId = &traceId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AggregationValidatorClient::recv_validateTrace(ValidateTraceResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("validateTrace") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + AggregationValidator_validateTrace_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validateTrace failed: unknown result"); +} + +bool AggregationValidatorProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void AggregationValidatorProcessor::process_validateTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("AggregationValidator.validateTrace", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "AggregationValidator.validateTrace"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "AggregationValidator.validateTrace"); + } + + AggregationValidator_validateTrace_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "AggregationValidator.validateTrace", bytes); + } + + AggregationValidator_validateTrace_result result; + try { + iface_->validateTrace(result.success, args.traceId); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "AggregationValidator.validateTrace"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("validateTrace", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "AggregationValidator.validateTrace"); + } + + oprot->writeMessageBegin("validateTrace", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "AggregationValidator.validateTrace", bytes); + } +} + +::std::shared_ptr< ::apache::thrift::TProcessor > AggregationValidatorProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< AggregationValidatorIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< AggregationValidatorIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new AggregationValidatorProcessor(handler)); + return processor; +} + +void AggregationValidatorConcurrentClient::validateTrace(ValidateTraceResponse& _return, const std::string& traceId) +{ + int32_t seqid = send_validateTrace(traceId); + recv_validateTrace(_return, seqid); +} + +int32_t AggregationValidatorConcurrentClient::send_validateTrace(const std::string& traceId) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("validateTrace", ::apache::thrift::protocol::T_CALL, cseqid); + + AggregationValidator_validateTrace_pargs args; + args.traceId = &traceId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void AggregationValidatorConcurrentClient::recv_validateTrace(ValidateTraceResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("validateTrace") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + AggregationValidator_validateTrace_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validateTrace failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/AggregationValidator.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/AggregationValidator.h new file mode 100644 index 000000000..5510ecfac --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/AggregationValidator.h @@ -0,0 +1,290 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef AggregationValidator_H +#define AggregationValidator_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "aggregation_validator_types.h" + +namespace jaegertracing { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class AggregationValidatorIf { + public: + virtual ~AggregationValidatorIf() {} + virtual void validateTrace(ValidateTraceResponse& _return, const std::string& traceId) = 0; +}; + +class AggregationValidatorIfFactory { + public: + typedef AggregationValidatorIf Handler; + + virtual ~AggregationValidatorIfFactory() {} + + virtual AggregationValidatorIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(AggregationValidatorIf* /* handler */) = 0; +}; + +class AggregationValidatorIfSingletonFactory : virtual public AggregationValidatorIfFactory { + public: + AggregationValidatorIfSingletonFactory(const ::std::shared_ptr<AggregationValidatorIf>& iface) : iface_(iface) {} + virtual ~AggregationValidatorIfSingletonFactory() {} + + virtual AggregationValidatorIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(AggregationValidatorIf* /* handler */) {} + + protected: + ::std::shared_ptr<AggregationValidatorIf> iface_; +}; + +class AggregationValidatorNull : virtual public AggregationValidatorIf { + public: + virtual ~AggregationValidatorNull() {} + void validateTrace(ValidateTraceResponse& /* _return */, const std::string& /* traceId */) { + return; + } +}; + + +class AggregationValidator_validateTrace_args { + public: + + AggregationValidator_validateTrace_args(const AggregationValidator_validateTrace_args&); + AggregationValidator_validateTrace_args& operator=(const AggregationValidator_validateTrace_args&); + AggregationValidator_validateTrace_args() : traceId() { + } + + virtual ~AggregationValidator_validateTrace_args() throw(); + std::string traceId; + + void __set_traceId(const std::string& val); + + bool operator == (const AggregationValidator_validateTrace_args & rhs) const + { + if (!(traceId == rhs.traceId)) + return false; + return true; + } + bool operator != (const AggregationValidator_validateTrace_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AggregationValidator_validateTrace_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AggregationValidator_validateTrace_pargs { + public: + + + virtual ~AggregationValidator_validateTrace_pargs() throw(); + const std::string* traceId; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AggregationValidator_validateTrace_result__isset { + _AggregationValidator_validateTrace_result__isset() : success(false) {} + bool success :1; +} _AggregationValidator_validateTrace_result__isset; + +class AggregationValidator_validateTrace_result { + public: + + AggregationValidator_validateTrace_result(const AggregationValidator_validateTrace_result&); + AggregationValidator_validateTrace_result& operator=(const AggregationValidator_validateTrace_result&); + AggregationValidator_validateTrace_result() { + } + + virtual ~AggregationValidator_validateTrace_result() throw(); + ValidateTraceResponse success; + + _AggregationValidator_validateTrace_result__isset __isset; + + void __set_success(const ValidateTraceResponse& val); + + bool operator == (const AggregationValidator_validateTrace_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const AggregationValidator_validateTrace_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AggregationValidator_validateTrace_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AggregationValidator_validateTrace_presult__isset { + _AggregationValidator_validateTrace_presult__isset() : success(false) {} + bool success :1; +} _AggregationValidator_validateTrace_presult__isset; + +class AggregationValidator_validateTrace_presult { + public: + + + virtual ~AggregationValidator_validateTrace_presult() throw(); + ValidateTraceResponse* success; + + _AggregationValidator_validateTrace_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +class AggregationValidatorClient : virtual public AggregationValidatorIf { + public: + AggregationValidatorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + AggregationValidatorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void validateTrace(ValidateTraceResponse& _return, const std::string& traceId); + void send_validateTrace(const std::string& traceId); + void recv_validateTrace(ValidateTraceResponse& _return); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class AggregationValidatorProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<AggregationValidatorIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (AggregationValidatorProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_validateTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + AggregationValidatorProcessor(::std::shared_ptr<AggregationValidatorIf> iface) : + iface_(iface) { + processMap_["validateTrace"] = &AggregationValidatorProcessor::process_validateTrace; + } + + virtual ~AggregationValidatorProcessor() {} +}; + +class AggregationValidatorProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + AggregationValidatorProcessorFactory(const ::std::shared_ptr< AggregationValidatorIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< AggregationValidatorIfFactory > handlerFactory_; +}; + +class AggregationValidatorMultiface : virtual public AggregationValidatorIf { + public: + AggregationValidatorMultiface(std::vector<std::shared_ptr<AggregationValidatorIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~AggregationValidatorMultiface() {} + protected: + std::vector<std::shared_ptr<AggregationValidatorIf> > ifaces_; + AggregationValidatorMultiface() {} + void add(::std::shared_ptr<AggregationValidatorIf> iface) { + ifaces_.push_back(iface); + } + public: + void validateTrace(ValidateTraceResponse& _return, const std::string& traceId) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->validateTrace(_return, traceId); + } + ifaces_[i]->validateTrace(_return, traceId); + return; + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class AggregationValidatorConcurrentClient : virtual public AggregationValidatorIf { + public: + AggregationValidatorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + AggregationValidatorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void validateTrace(ValidateTraceResponse& _return, const std::string& traceId); + int32_t send_validateTrace(const std::string& traceId); + void recv_validateTrace(ValidateTraceResponse& _return, const int32_t seqid); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.cpp new file mode 100644 index 000000000..b929fbbd3 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.cpp @@ -0,0 +1,453 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "BaggageRestrictionManager.h" + +namespace jaegertracing { namespace thrift { + + +BaggageRestrictionManager_getBaggageRestrictions_args::~BaggageRestrictionManager_getBaggageRestrictions_args() throw() { +} + + +uint32_t BaggageRestrictionManager_getBaggageRestrictions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serviceName); + this->__isset.serviceName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t BaggageRestrictionManager_getBaggageRestrictions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("BaggageRestrictionManager_getBaggageRestrictions_args"); + + xfer += oprot->writeFieldBegin("serviceName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->serviceName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +BaggageRestrictionManager_getBaggageRestrictions_pargs::~BaggageRestrictionManager_getBaggageRestrictions_pargs() throw() { +} + + +uint32_t BaggageRestrictionManager_getBaggageRestrictions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("BaggageRestrictionManager_getBaggageRestrictions_pargs"); + + xfer += oprot->writeFieldBegin("serviceName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->serviceName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +BaggageRestrictionManager_getBaggageRestrictions_result::~BaggageRestrictionManager_getBaggageRestrictions_result() throw() { +} + + +uint32_t BaggageRestrictionManager_getBaggageRestrictions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size2; + ::apache::thrift::protocol::TType _etype5; + xfer += iprot->readListBegin(_etype5, _size2); + this->success.resize(_size2); + uint32_t _i6; + for (_i6 = 0; _i6 < _size2; ++_i6) + { + xfer += this->success[_i6].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t BaggageRestrictionManager_getBaggageRestrictions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("BaggageRestrictionManager_getBaggageRestrictions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); + std::vector<BaggageRestriction> ::const_iterator _iter7; + for (_iter7 = this->success.begin(); _iter7 != this->success.end(); ++_iter7) + { + xfer += (*_iter7).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +BaggageRestrictionManager_getBaggageRestrictions_presult::~BaggageRestrictionManager_getBaggageRestrictions_presult() throw() { +} + + +uint32_t BaggageRestrictionManager_getBaggageRestrictions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size8; + ::apache::thrift::protocol::TType _etype11; + xfer += iprot->readListBegin(_etype11, _size8); + (*(this->success)).resize(_size8); + uint32_t _i12; + for (_i12 = 0; _i12 < _size8; ++_i12) + { + xfer += (*(this->success))[_i12].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +void BaggageRestrictionManagerClient::getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName) +{ + send_getBaggageRestrictions(serviceName); + recv_getBaggageRestrictions(_return); +} + +void BaggageRestrictionManagerClient::send_getBaggageRestrictions(const std::string& serviceName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getBaggageRestrictions", ::apache::thrift::protocol::T_CALL, cseqid); + + BaggageRestrictionManager_getBaggageRestrictions_pargs args; + args.serviceName = &serviceName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void BaggageRestrictionManagerClient::recv_getBaggageRestrictions(std::vector<BaggageRestriction> & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getBaggageRestrictions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + BaggageRestrictionManager_getBaggageRestrictions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getBaggageRestrictions failed: unknown result"); +} + +bool BaggageRestrictionManagerProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void BaggageRestrictionManagerProcessor::process_getBaggageRestrictions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("BaggageRestrictionManager.getBaggageRestrictions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "BaggageRestrictionManager.getBaggageRestrictions"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "BaggageRestrictionManager.getBaggageRestrictions"); + } + + BaggageRestrictionManager_getBaggageRestrictions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "BaggageRestrictionManager.getBaggageRestrictions", bytes); + } + + BaggageRestrictionManager_getBaggageRestrictions_result result; + try { + iface_->getBaggageRestrictions(result.success, args.serviceName); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "BaggageRestrictionManager.getBaggageRestrictions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getBaggageRestrictions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "BaggageRestrictionManager.getBaggageRestrictions"); + } + + oprot->writeMessageBegin("getBaggageRestrictions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "BaggageRestrictionManager.getBaggageRestrictions", bytes); + } +} + +::std::shared_ptr< ::apache::thrift::TProcessor > BaggageRestrictionManagerProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< BaggageRestrictionManagerIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< BaggageRestrictionManagerIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new BaggageRestrictionManagerProcessor(handler)); + return processor; +} + +void BaggageRestrictionManagerConcurrentClient::getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName) +{ + int32_t seqid = send_getBaggageRestrictions(serviceName); + recv_getBaggageRestrictions(_return, seqid); +} + +int32_t BaggageRestrictionManagerConcurrentClient::send_getBaggageRestrictions(const std::string& serviceName) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("getBaggageRestrictions", ::apache::thrift::protocol::T_CALL, cseqid); + + BaggageRestrictionManager_getBaggageRestrictions_pargs args; + args.serviceName = &serviceName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void BaggageRestrictionManagerConcurrentClient::recv_getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getBaggageRestrictions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + BaggageRestrictionManager_getBaggageRestrictions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getBaggageRestrictions failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.h new file mode 100644 index 000000000..442dc12a5 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.h @@ -0,0 +1,304 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef BaggageRestrictionManager_H +#define BaggageRestrictionManager_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "baggage_types.h" + +namespace jaegertracing { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class BaggageRestrictionManagerIf { + public: + virtual ~BaggageRestrictionManagerIf() {} + + /** + * getBaggageRestrictions retrieves the baggage restrictions for a specific service. + * Usually, baggageRestrictions apply to all services however there may be situations + * where a baggageKey might only be allowed to be set by a specific service. + * + * @param serviceName + */ + virtual void getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName) = 0; +}; + +class BaggageRestrictionManagerIfFactory { + public: + typedef BaggageRestrictionManagerIf Handler; + + virtual ~BaggageRestrictionManagerIfFactory() {} + + virtual BaggageRestrictionManagerIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(BaggageRestrictionManagerIf* /* handler */) = 0; +}; + +class BaggageRestrictionManagerIfSingletonFactory : virtual public BaggageRestrictionManagerIfFactory { + public: + BaggageRestrictionManagerIfSingletonFactory(const ::std::shared_ptr<BaggageRestrictionManagerIf>& iface) : iface_(iface) {} + virtual ~BaggageRestrictionManagerIfSingletonFactory() {} + + virtual BaggageRestrictionManagerIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(BaggageRestrictionManagerIf* /* handler */) {} + + protected: + ::std::shared_ptr<BaggageRestrictionManagerIf> iface_; +}; + +class BaggageRestrictionManagerNull : virtual public BaggageRestrictionManagerIf { + public: + virtual ~BaggageRestrictionManagerNull() {} + void getBaggageRestrictions(std::vector<BaggageRestriction> & /* _return */, const std::string& /* serviceName */) { + return; + } +}; + +typedef struct _BaggageRestrictionManager_getBaggageRestrictions_args__isset { + _BaggageRestrictionManager_getBaggageRestrictions_args__isset() : serviceName(false) {} + bool serviceName :1; +} _BaggageRestrictionManager_getBaggageRestrictions_args__isset; + +class BaggageRestrictionManager_getBaggageRestrictions_args { + public: + + BaggageRestrictionManager_getBaggageRestrictions_args(const BaggageRestrictionManager_getBaggageRestrictions_args&); + BaggageRestrictionManager_getBaggageRestrictions_args& operator=(const BaggageRestrictionManager_getBaggageRestrictions_args&); + BaggageRestrictionManager_getBaggageRestrictions_args() : serviceName() { + } + + virtual ~BaggageRestrictionManager_getBaggageRestrictions_args() throw(); + std::string serviceName; + + _BaggageRestrictionManager_getBaggageRestrictions_args__isset __isset; + + void __set_serviceName(const std::string& val); + + bool operator == (const BaggageRestrictionManager_getBaggageRestrictions_args & rhs) const + { + if (!(serviceName == rhs.serviceName)) + return false; + return true; + } + bool operator != (const BaggageRestrictionManager_getBaggageRestrictions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BaggageRestrictionManager_getBaggageRestrictions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class BaggageRestrictionManager_getBaggageRestrictions_pargs { + public: + + + virtual ~BaggageRestrictionManager_getBaggageRestrictions_pargs() throw(); + const std::string* serviceName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _BaggageRestrictionManager_getBaggageRestrictions_result__isset { + _BaggageRestrictionManager_getBaggageRestrictions_result__isset() : success(false) {} + bool success :1; +} _BaggageRestrictionManager_getBaggageRestrictions_result__isset; + +class BaggageRestrictionManager_getBaggageRestrictions_result { + public: + + BaggageRestrictionManager_getBaggageRestrictions_result(const BaggageRestrictionManager_getBaggageRestrictions_result&); + BaggageRestrictionManager_getBaggageRestrictions_result& operator=(const BaggageRestrictionManager_getBaggageRestrictions_result&); + BaggageRestrictionManager_getBaggageRestrictions_result() { + } + + virtual ~BaggageRestrictionManager_getBaggageRestrictions_result() throw(); + std::vector<BaggageRestriction> success; + + _BaggageRestrictionManager_getBaggageRestrictions_result__isset __isset; + + void __set_success(const std::vector<BaggageRestriction> & val); + + bool operator == (const BaggageRestrictionManager_getBaggageRestrictions_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const BaggageRestrictionManager_getBaggageRestrictions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BaggageRestrictionManager_getBaggageRestrictions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _BaggageRestrictionManager_getBaggageRestrictions_presult__isset { + _BaggageRestrictionManager_getBaggageRestrictions_presult__isset() : success(false) {} + bool success :1; +} _BaggageRestrictionManager_getBaggageRestrictions_presult__isset; + +class BaggageRestrictionManager_getBaggageRestrictions_presult { + public: + + + virtual ~BaggageRestrictionManager_getBaggageRestrictions_presult() throw(); + std::vector<BaggageRestriction> * success; + + _BaggageRestrictionManager_getBaggageRestrictions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +class BaggageRestrictionManagerClient : virtual public BaggageRestrictionManagerIf { + public: + BaggageRestrictionManagerClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + BaggageRestrictionManagerClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName); + void send_getBaggageRestrictions(const std::string& serviceName); + void recv_getBaggageRestrictions(std::vector<BaggageRestriction> & _return); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class BaggageRestrictionManagerProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<BaggageRestrictionManagerIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (BaggageRestrictionManagerProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_getBaggageRestrictions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + BaggageRestrictionManagerProcessor(::std::shared_ptr<BaggageRestrictionManagerIf> iface) : + iface_(iface) { + processMap_["getBaggageRestrictions"] = &BaggageRestrictionManagerProcessor::process_getBaggageRestrictions; + } + + virtual ~BaggageRestrictionManagerProcessor() {} +}; + +class BaggageRestrictionManagerProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + BaggageRestrictionManagerProcessorFactory(const ::std::shared_ptr< BaggageRestrictionManagerIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< BaggageRestrictionManagerIfFactory > handlerFactory_; +}; + +class BaggageRestrictionManagerMultiface : virtual public BaggageRestrictionManagerIf { + public: + BaggageRestrictionManagerMultiface(std::vector<std::shared_ptr<BaggageRestrictionManagerIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~BaggageRestrictionManagerMultiface() {} + protected: + std::vector<std::shared_ptr<BaggageRestrictionManagerIf> > ifaces_; + BaggageRestrictionManagerMultiface() {} + void add(::std::shared_ptr<BaggageRestrictionManagerIf> iface) { + ifaces_.push_back(iface); + } + public: + void getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getBaggageRestrictions(_return, serviceName); + } + ifaces_[i]->getBaggageRestrictions(_return, serviceName); + return; + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class BaggageRestrictionManagerConcurrentClient : virtual public BaggageRestrictionManagerIf { + public: + BaggageRestrictionManagerConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + BaggageRestrictionManagerConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName); + int32_t send_getBaggageRestrictions(const std::string& serviceName); + void recv_getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const int32_t seqid); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Collector.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Collector.cpp new file mode 100644 index 000000000..795264fc2 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Collector.cpp @@ -0,0 +1,481 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "Collector.h" + +namespace jaegertracing { namespace thrift { + + +Collector_submitBatches_args::~Collector_submitBatches_args() throw() { +} + + +uint32_t Collector_submitBatches_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->batches.clear(); + uint32_t _size52; + ::apache::thrift::protocol::TType _etype55; + xfer += iprot->readListBegin(_etype55, _size52); + this->batches.resize(_size52); + uint32_t _i56; + for (_i56 = 0; _i56 < _size52; ++_i56) + { + xfer += this->batches[_i56].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.batches = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Collector_submitBatches_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Collector_submitBatches_args"); + + xfer += oprot->writeFieldBegin("batches", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->batches.size())); + std::vector<Batch> ::const_iterator _iter57; + for (_iter57 = this->batches.begin(); _iter57 != this->batches.end(); ++_iter57) + { + xfer += (*_iter57).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Collector_submitBatches_pargs::~Collector_submitBatches_pargs() throw() { +} + + +uint32_t Collector_submitBatches_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Collector_submitBatches_pargs"); + + xfer += oprot->writeFieldBegin("batches", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->batches)).size())); + std::vector<Batch> ::const_iterator _iter58; + for (_iter58 = (*(this->batches)).begin(); _iter58 != (*(this->batches)).end(); ++_iter58) + { + xfer += (*_iter58).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Collector_submitBatches_result::~Collector_submitBatches_result() throw() { +} + + +uint32_t Collector_submitBatches_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size59; + ::apache::thrift::protocol::TType _etype62; + xfer += iprot->readListBegin(_etype62, _size59); + this->success.resize(_size59); + uint32_t _i63; + for (_i63 = 0; _i63 < _size59; ++_i63) + { + xfer += this->success[_i63].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Collector_submitBatches_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Collector_submitBatches_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); + std::vector<BatchSubmitResponse> ::const_iterator _iter64; + for (_iter64 = this->success.begin(); _iter64 != this->success.end(); ++_iter64) + { + xfer += (*_iter64).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Collector_submitBatches_presult::~Collector_submitBatches_presult() throw() { +} + + +uint32_t Collector_submitBatches_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size65; + ::apache::thrift::protocol::TType _etype68; + xfer += iprot->readListBegin(_etype68, _size65); + (*(this->success)).resize(_size65); + uint32_t _i69; + for (_i69 = 0; _i69 < _size65; ++_i69) + { + xfer += (*(this->success))[_i69].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +void CollectorClient::submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches) +{ + send_submitBatches(batches); + recv_submitBatches(_return); +} + +void CollectorClient::send_submitBatches(const std::vector<Batch> & batches) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("submitBatches", ::apache::thrift::protocol::T_CALL, cseqid); + + Collector_submitBatches_pargs args; + args.batches = &batches; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void CollectorClient::recv_submitBatches(std::vector<BatchSubmitResponse> & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("submitBatches") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Collector_submitBatches_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submitBatches failed: unknown result"); +} + +bool CollectorProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void CollectorProcessor::process_submitBatches(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("Collector.submitBatches", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Collector.submitBatches"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "Collector.submitBatches"); + } + + Collector_submitBatches_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "Collector.submitBatches", bytes); + } + + Collector_submitBatches_result result; + try { + iface_->submitBatches(result.success, args.batches); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "Collector.submitBatches"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("submitBatches", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "Collector.submitBatches"); + } + + oprot->writeMessageBegin("submitBatches", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "Collector.submitBatches", bytes); + } +} + +::std::shared_ptr< ::apache::thrift::TProcessor > CollectorProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< CollectorIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< CollectorIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new CollectorProcessor(handler)); + return processor; +} + +void CollectorConcurrentClient::submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches) +{ + int32_t seqid = send_submitBatches(batches); + recv_submitBatches(_return, seqid); +} + +int32_t CollectorConcurrentClient::send_submitBatches(const std::vector<Batch> & batches) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("submitBatches", ::apache::thrift::protocol::T_CALL, cseqid); + + Collector_submitBatches_pargs args; + args.batches = &batches; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void CollectorConcurrentClient::recv_submitBatches(std::vector<BatchSubmitResponse> & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("submitBatches") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + Collector_submitBatches_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submitBatches failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Collector.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Collector.h new file mode 100644 index 000000000..4cca6550c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Collector.h @@ -0,0 +1,296 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef Collector_H +#define Collector_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "jaeger_types.h" + +namespace jaegertracing { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class CollectorIf { + public: + virtual ~CollectorIf() {} + virtual void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches) = 0; +}; + +class CollectorIfFactory { + public: + typedef CollectorIf Handler; + + virtual ~CollectorIfFactory() {} + + virtual CollectorIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(CollectorIf* /* handler */) = 0; +}; + +class CollectorIfSingletonFactory : virtual public CollectorIfFactory { + public: + CollectorIfSingletonFactory(const ::std::shared_ptr<CollectorIf>& iface) : iface_(iface) {} + virtual ~CollectorIfSingletonFactory() {} + + virtual CollectorIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(CollectorIf* /* handler */) {} + + protected: + ::std::shared_ptr<CollectorIf> iface_; +}; + +class CollectorNull : virtual public CollectorIf { + public: + virtual ~CollectorNull() {} + void submitBatches(std::vector<BatchSubmitResponse> & /* _return */, const std::vector<Batch> & /* batches */) { + return; + } +}; + +typedef struct _Collector_submitBatches_args__isset { + _Collector_submitBatches_args__isset() : batches(false) {} + bool batches :1; +} _Collector_submitBatches_args__isset; + +class Collector_submitBatches_args { + public: + + Collector_submitBatches_args(const Collector_submitBatches_args&); + Collector_submitBatches_args& operator=(const Collector_submitBatches_args&); + Collector_submitBatches_args() { + } + + virtual ~Collector_submitBatches_args() throw(); + std::vector<Batch> batches; + + _Collector_submitBatches_args__isset __isset; + + void __set_batches(const std::vector<Batch> & val); + + bool operator == (const Collector_submitBatches_args & rhs) const + { + if (!(batches == rhs.batches)) + return false; + return true; + } + bool operator != (const Collector_submitBatches_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Collector_submitBatches_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class Collector_submitBatches_pargs { + public: + + + virtual ~Collector_submitBatches_pargs() throw(); + const std::vector<Batch> * batches; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _Collector_submitBatches_result__isset { + _Collector_submitBatches_result__isset() : success(false) {} + bool success :1; +} _Collector_submitBatches_result__isset; + +class Collector_submitBatches_result { + public: + + Collector_submitBatches_result(const Collector_submitBatches_result&); + Collector_submitBatches_result& operator=(const Collector_submitBatches_result&); + Collector_submitBatches_result() { + } + + virtual ~Collector_submitBatches_result() throw(); + std::vector<BatchSubmitResponse> success; + + _Collector_submitBatches_result__isset __isset; + + void __set_success(const std::vector<BatchSubmitResponse> & val); + + bool operator == (const Collector_submitBatches_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const Collector_submitBatches_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Collector_submitBatches_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _Collector_submitBatches_presult__isset { + _Collector_submitBatches_presult__isset() : success(false) {} + bool success :1; +} _Collector_submitBatches_presult__isset; + +class Collector_submitBatches_presult { + public: + + + virtual ~Collector_submitBatches_presult() throw(); + std::vector<BatchSubmitResponse> * success; + + _Collector_submitBatches_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +class CollectorClient : virtual public CollectorIf { + public: + CollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + CollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches); + void send_submitBatches(const std::vector<Batch> & batches); + void recv_submitBatches(std::vector<BatchSubmitResponse> & _return); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class CollectorProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<CollectorIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (CollectorProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_submitBatches(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + CollectorProcessor(::std::shared_ptr<CollectorIf> iface) : + iface_(iface) { + processMap_["submitBatches"] = &CollectorProcessor::process_submitBatches; + } + + virtual ~CollectorProcessor() {} +}; + +class CollectorProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + CollectorProcessorFactory(const ::std::shared_ptr< CollectorIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< CollectorIfFactory > handlerFactory_; +}; + +class CollectorMultiface : virtual public CollectorIf { + public: + CollectorMultiface(std::vector<std::shared_ptr<CollectorIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~CollectorMultiface() {} + protected: + std::vector<std::shared_ptr<CollectorIf> > ifaces_; + CollectorMultiface() {} + void add(::std::shared_ptr<CollectorIf> iface) { + ifaces_.push_back(iface); + } + public: + void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->submitBatches(_return, batches); + } + ifaces_[i]->submitBatches(_return, batches); + return; + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class CollectorConcurrentClient : virtual public CollectorIf { + public: + CollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + CollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches); + int32_t send_submitBatches(const std::vector<Batch> & batches); + void recv_submitBatches(std::vector<BatchSubmitResponse> & _return, const int32_t seqid); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Dependency.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Dependency.cpp new file mode 100644 index 000000000..d34f55c5a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Dependency.cpp @@ -0,0 +1,581 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "Dependency.h" + +namespace jaegertracing { namespace thrift { + + +Dependency_getDependenciesForTrace_args::~Dependency_getDependenciesForTrace_args() throw() { +} + + +uint32_t Dependency_getDependenciesForTrace_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_traceId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->traceId); + isset_traceId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_traceId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Dependency_getDependenciesForTrace_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Dependency_getDependenciesForTrace_args"); + + xfer += oprot->writeFieldBegin("traceId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->traceId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Dependency_getDependenciesForTrace_pargs::~Dependency_getDependenciesForTrace_pargs() throw() { +} + + +uint32_t Dependency_getDependenciesForTrace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Dependency_getDependenciesForTrace_pargs"); + + xfer += oprot->writeFieldBegin("traceId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->traceId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Dependency_getDependenciesForTrace_result::~Dependency_getDependenciesForTrace_result() throw() { +} + + +uint32_t Dependency_getDependenciesForTrace_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Dependency_getDependenciesForTrace_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Dependency_getDependenciesForTrace_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Dependency_getDependenciesForTrace_presult::~Dependency_getDependenciesForTrace_presult() throw() { +} + + +uint32_t Dependency_getDependenciesForTrace_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Dependency_saveDependencies_args::~Dependency_saveDependencies_args() throw() { +} + + +uint32_t Dependency_saveDependencies_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->dependencies.read(iprot); + this->__isset.dependencies = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Dependency_saveDependencies_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Dependency_saveDependencies_args"); + + xfer += oprot->writeFieldBegin("dependencies", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->dependencies.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Dependency_saveDependencies_pargs::~Dependency_saveDependencies_pargs() throw() { +} + + +uint32_t Dependency_saveDependencies_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Dependency_saveDependencies_pargs"); + + xfer += oprot->writeFieldBegin("dependencies", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->dependencies)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void DependencyClient::getDependenciesForTrace(Dependencies& _return, const std::string& traceId) +{ + send_getDependenciesForTrace(traceId); + recv_getDependenciesForTrace(_return); +} + +void DependencyClient::send_getDependenciesForTrace(const std::string& traceId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getDependenciesForTrace", ::apache::thrift::protocol::T_CALL, cseqid); + + Dependency_getDependenciesForTrace_pargs args; + args.traceId = &traceId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void DependencyClient::recv_getDependenciesForTrace(Dependencies& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getDependenciesForTrace") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Dependency_getDependenciesForTrace_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getDependenciesForTrace failed: unknown result"); +} + +void DependencyClient::saveDependencies(const Dependencies& dependencies) +{ + send_saveDependencies(dependencies); +} + +void DependencyClient::send_saveDependencies(const Dependencies& dependencies) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("saveDependencies", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + Dependency_saveDependencies_pargs args; + args.dependencies = &dependencies; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool DependencyProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void DependencyProcessor::process_getDependenciesForTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("Dependency.getDependenciesForTrace", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Dependency.getDependenciesForTrace"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "Dependency.getDependenciesForTrace"); + } + + Dependency_getDependenciesForTrace_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "Dependency.getDependenciesForTrace", bytes); + } + + Dependency_getDependenciesForTrace_result result; + try { + iface_->getDependenciesForTrace(result.success, args.traceId); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "Dependency.getDependenciesForTrace"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getDependenciesForTrace", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "Dependency.getDependenciesForTrace"); + } + + oprot->writeMessageBegin("getDependenciesForTrace", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "Dependency.getDependenciesForTrace", bytes); + } +} + +void DependencyProcessor::process_saveDependencies(int32_t, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol*, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("Dependency.saveDependencies", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Dependency.saveDependencies"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "Dependency.saveDependencies"); + } + + Dependency_saveDependencies_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "Dependency.saveDependencies", bytes); + } + + try { + iface_->saveDependencies(args.dependencies); + } catch (const std::exception&) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "Dependency.saveDependencies"); + } + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->asyncComplete(ctx, "Dependency.saveDependencies"); + } + + return; +} + +::std::shared_ptr< ::apache::thrift::TProcessor > DependencyProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< DependencyIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< DependencyIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new DependencyProcessor(handler)); + return processor; +} + +void DependencyConcurrentClient::getDependenciesForTrace(Dependencies& _return, const std::string& traceId) +{ + int32_t seqid = send_getDependenciesForTrace(traceId); + recv_getDependenciesForTrace(_return, seqid); +} + +int32_t DependencyConcurrentClient::send_getDependenciesForTrace(const std::string& traceId) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("getDependenciesForTrace", ::apache::thrift::protocol::T_CALL, cseqid); + + Dependency_getDependenciesForTrace_pargs args; + args.traceId = &traceId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void DependencyConcurrentClient::recv_getDependenciesForTrace(Dependencies& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getDependenciesForTrace") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + Dependency_getDependenciesForTrace_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getDependenciesForTrace failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void DependencyConcurrentClient::saveDependencies(const Dependencies& dependencies) +{ + send_saveDependencies(dependencies); +} + +void DependencyConcurrentClient::send_saveDependencies(const Dependencies& dependencies) +{ + int32_t cseqid = 0; + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("saveDependencies", ::apache::thrift::protocol::T_ONEWAY, cseqid); + + Dependency_saveDependencies_pargs args; + args.dependencies = &dependencies; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); +} + +}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Dependency.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Dependency.h new file mode 100644 index 000000000..648198b1a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/Dependency.h @@ -0,0 +1,358 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef Dependency_H +#define Dependency_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "dependency_types.h" + +namespace jaegertracing { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class DependencyIf { + public: + virtual ~DependencyIf() {} + virtual void getDependenciesForTrace(Dependencies& _return, const std::string& traceId) = 0; + virtual void saveDependencies(const Dependencies& dependencies) = 0; +}; + +class DependencyIfFactory { + public: + typedef DependencyIf Handler; + + virtual ~DependencyIfFactory() {} + + virtual DependencyIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(DependencyIf* /* handler */) = 0; +}; + +class DependencyIfSingletonFactory : virtual public DependencyIfFactory { + public: + DependencyIfSingletonFactory(const ::std::shared_ptr<DependencyIf>& iface) : iface_(iface) {} + virtual ~DependencyIfSingletonFactory() {} + + virtual DependencyIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(DependencyIf* /* handler */) {} + + protected: + ::std::shared_ptr<DependencyIf> iface_; +}; + +class DependencyNull : virtual public DependencyIf { + public: + virtual ~DependencyNull() {} + void getDependenciesForTrace(Dependencies& /* _return */, const std::string& /* traceId */) { + return; + } + void saveDependencies(const Dependencies& /* dependencies */) { + return; + } +}; + + +class Dependency_getDependenciesForTrace_args { + public: + + Dependency_getDependenciesForTrace_args(const Dependency_getDependenciesForTrace_args&); + Dependency_getDependenciesForTrace_args& operator=(const Dependency_getDependenciesForTrace_args&); + Dependency_getDependenciesForTrace_args() : traceId() { + } + + virtual ~Dependency_getDependenciesForTrace_args() throw(); + std::string traceId; + + void __set_traceId(const std::string& val); + + bool operator == (const Dependency_getDependenciesForTrace_args & rhs) const + { + if (!(traceId == rhs.traceId)) + return false; + return true; + } + bool operator != (const Dependency_getDependenciesForTrace_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Dependency_getDependenciesForTrace_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class Dependency_getDependenciesForTrace_pargs { + public: + + + virtual ~Dependency_getDependenciesForTrace_pargs() throw(); + const std::string* traceId; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _Dependency_getDependenciesForTrace_result__isset { + _Dependency_getDependenciesForTrace_result__isset() : success(false) {} + bool success :1; +} _Dependency_getDependenciesForTrace_result__isset; + +class Dependency_getDependenciesForTrace_result { + public: + + Dependency_getDependenciesForTrace_result(const Dependency_getDependenciesForTrace_result&); + Dependency_getDependenciesForTrace_result& operator=(const Dependency_getDependenciesForTrace_result&); + Dependency_getDependenciesForTrace_result() { + } + + virtual ~Dependency_getDependenciesForTrace_result() throw(); + Dependencies success; + + _Dependency_getDependenciesForTrace_result__isset __isset; + + void __set_success(const Dependencies& val); + + bool operator == (const Dependency_getDependenciesForTrace_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const Dependency_getDependenciesForTrace_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Dependency_getDependenciesForTrace_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _Dependency_getDependenciesForTrace_presult__isset { + _Dependency_getDependenciesForTrace_presult__isset() : success(false) {} + bool success :1; +} _Dependency_getDependenciesForTrace_presult__isset; + +class Dependency_getDependenciesForTrace_presult { + public: + + + virtual ~Dependency_getDependenciesForTrace_presult() throw(); + Dependencies* success; + + _Dependency_getDependenciesForTrace_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _Dependency_saveDependencies_args__isset { + _Dependency_saveDependencies_args__isset() : dependencies(false) {} + bool dependencies :1; +} _Dependency_saveDependencies_args__isset; + +class Dependency_saveDependencies_args { + public: + + Dependency_saveDependencies_args(const Dependency_saveDependencies_args&); + Dependency_saveDependencies_args& operator=(const Dependency_saveDependencies_args&); + Dependency_saveDependencies_args() { + } + + virtual ~Dependency_saveDependencies_args() throw(); + Dependencies dependencies; + + _Dependency_saveDependencies_args__isset __isset; + + void __set_dependencies(const Dependencies& val); + + bool operator == (const Dependency_saveDependencies_args & rhs) const + { + if (!(dependencies == rhs.dependencies)) + return false; + return true; + } + bool operator != (const Dependency_saveDependencies_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Dependency_saveDependencies_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class Dependency_saveDependencies_pargs { + public: + + + virtual ~Dependency_saveDependencies_pargs() throw(); + const Dependencies* dependencies; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +class DependencyClient : virtual public DependencyIf { + public: + DependencyClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + DependencyClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getDependenciesForTrace(Dependencies& _return, const std::string& traceId); + void send_getDependenciesForTrace(const std::string& traceId); + void recv_getDependenciesForTrace(Dependencies& _return); + void saveDependencies(const Dependencies& dependencies); + void send_saveDependencies(const Dependencies& dependencies); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class DependencyProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<DependencyIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (DependencyProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_getDependenciesForTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_saveDependencies(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + DependencyProcessor(::std::shared_ptr<DependencyIf> iface) : + iface_(iface) { + processMap_["getDependenciesForTrace"] = &DependencyProcessor::process_getDependenciesForTrace; + processMap_["saveDependencies"] = &DependencyProcessor::process_saveDependencies; + } + + virtual ~DependencyProcessor() {} +}; + +class DependencyProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + DependencyProcessorFactory(const ::std::shared_ptr< DependencyIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< DependencyIfFactory > handlerFactory_; +}; + +class DependencyMultiface : virtual public DependencyIf { + public: + DependencyMultiface(std::vector<std::shared_ptr<DependencyIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~DependencyMultiface() {} + protected: + std::vector<std::shared_ptr<DependencyIf> > ifaces_; + DependencyMultiface() {} + void add(::std::shared_ptr<DependencyIf> iface) { + ifaces_.push_back(iface); + } + public: + void getDependenciesForTrace(Dependencies& _return, const std::string& traceId) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getDependenciesForTrace(_return, traceId); + } + ifaces_[i]->getDependenciesForTrace(_return, traceId); + return; + } + + void saveDependencies(const Dependencies& dependencies) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->saveDependencies(dependencies); + } + ifaces_[i]->saveDependencies(dependencies); + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class DependencyConcurrentClient : virtual public DependencyIf { + public: + DependencyConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + DependencyConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getDependenciesForTrace(Dependencies& _return, const std::string& traceId); + int32_t send_getDependenciesForTrace(const std::string& traceId); + void recv_getDependenciesForTrace(Dependencies& _return, const int32_t seqid); + void saveDependencies(const Dependencies& dependencies); + void send_saveDependencies(const Dependencies& dependencies); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/SamplingManager.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/SamplingManager.cpp new file mode 100644 index 000000000..0da5d87cd --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/SamplingManager.cpp @@ -0,0 +1,421 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "SamplingManager.h" + +namespace jaegertracing { namespace sampling_manager { namespace thrift { + + +SamplingManager_getSamplingStrategy_args::~SamplingManager_getSamplingStrategy_args() throw() { +} + + +uint32_t SamplingManager_getSamplingStrategy_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serviceName); + this->__isset.serviceName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SamplingManager_getSamplingStrategy_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SamplingManager_getSamplingStrategy_args"); + + xfer += oprot->writeFieldBegin("serviceName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->serviceName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +SamplingManager_getSamplingStrategy_pargs::~SamplingManager_getSamplingStrategy_pargs() throw() { +} + + +uint32_t SamplingManager_getSamplingStrategy_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SamplingManager_getSamplingStrategy_pargs"); + + xfer += oprot->writeFieldBegin("serviceName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->serviceName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +SamplingManager_getSamplingStrategy_result::~SamplingManager_getSamplingStrategy_result() throw() { +} + + +uint32_t SamplingManager_getSamplingStrategy_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t SamplingManager_getSamplingStrategy_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("SamplingManager_getSamplingStrategy_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +SamplingManager_getSamplingStrategy_presult::~SamplingManager_getSamplingStrategy_presult() throw() { +} + + +uint32_t SamplingManager_getSamplingStrategy_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +void SamplingManagerClient::getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName) +{ + send_getSamplingStrategy(serviceName); + recv_getSamplingStrategy(_return); +} + +void SamplingManagerClient::send_getSamplingStrategy(const std::string& serviceName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getSamplingStrategy", ::apache::thrift::protocol::T_CALL, cseqid); + + SamplingManager_getSamplingStrategy_pargs args; + args.serviceName = &serviceName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void SamplingManagerClient::recv_getSamplingStrategy(SamplingStrategyResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getSamplingStrategy") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + SamplingManager_getSamplingStrategy_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getSamplingStrategy failed: unknown result"); +} + +bool SamplingManagerProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void SamplingManagerProcessor::process_getSamplingStrategy(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("SamplingManager.getSamplingStrategy", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SamplingManager.getSamplingStrategy"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "SamplingManager.getSamplingStrategy"); + } + + SamplingManager_getSamplingStrategy_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "SamplingManager.getSamplingStrategy", bytes); + } + + SamplingManager_getSamplingStrategy_result result; + try { + iface_->getSamplingStrategy(result.success, args.serviceName); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "SamplingManager.getSamplingStrategy"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("getSamplingStrategy", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "SamplingManager.getSamplingStrategy"); + } + + oprot->writeMessageBegin("getSamplingStrategy", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "SamplingManager.getSamplingStrategy", bytes); + } +} + +::std::shared_ptr< ::apache::thrift::TProcessor > SamplingManagerProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< SamplingManagerIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< SamplingManagerIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new SamplingManagerProcessor(handler)); + return processor; +} + +void SamplingManagerConcurrentClient::getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName) +{ + int32_t seqid = send_getSamplingStrategy(serviceName); + recv_getSamplingStrategy(_return, seqid); +} + +int32_t SamplingManagerConcurrentClient::send_getSamplingStrategy(const std::string& serviceName) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("getSamplingStrategy", ::apache::thrift::protocol::T_CALL, cseqid); + + SamplingManager_getSamplingStrategy_pargs args; + args.serviceName = &serviceName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void SamplingManagerConcurrentClient::recv_getSamplingStrategy(SamplingStrategyResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getSamplingStrategy") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + SamplingManager_getSamplingStrategy_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getSamplingStrategy failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +}}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/SamplingManager.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/SamplingManager.h new file mode 100644 index 000000000..1d67c618c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/SamplingManager.h @@ -0,0 +1,296 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef SamplingManager_H +#define SamplingManager_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "sampling_types.h" + +namespace jaegertracing { namespace sampling_manager { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class SamplingManagerIf { + public: + virtual ~SamplingManagerIf() {} + virtual void getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName) = 0; +}; + +class SamplingManagerIfFactory { + public: + typedef SamplingManagerIf Handler; + + virtual ~SamplingManagerIfFactory() {} + + virtual SamplingManagerIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(SamplingManagerIf* /* handler */) = 0; +}; + +class SamplingManagerIfSingletonFactory : virtual public SamplingManagerIfFactory { + public: + SamplingManagerIfSingletonFactory(const ::std::shared_ptr<SamplingManagerIf>& iface) : iface_(iface) {} + virtual ~SamplingManagerIfSingletonFactory() {} + + virtual SamplingManagerIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(SamplingManagerIf* /* handler */) {} + + protected: + ::std::shared_ptr<SamplingManagerIf> iface_; +}; + +class SamplingManagerNull : virtual public SamplingManagerIf { + public: + virtual ~SamplingManagerNull() {} + void getSamplingStrategy(SamplingStrategyResponse& /* _return */, const std::string& /* serviceName */) { + return; + } +}; + +typedef struct _SamplingManager_getSamplingStrategy_args__isset { + _SamplingManager_getSamplingStrategy_args__isset() : serviceName(false) {} + bool serviceName :1; +} _SamplingManager_getSamplingStrategy_args__isset; + +class SamplingManager_getSamplingStrategy_args { + public: + + SamplingManager_getSamplingStrategy_args(const SamplingManager_getSamplingStrategy_args&); + SamplingManager_getSamplingStrategy_args& operator=(const SamplingManager_getSamplingStrategy_args&); + SamplingManager_getSamplingStrategy_args() : serviceName() { + } + + virtual ~SamplingManager_getSamplingStrategy_args() throw(); + std::string serviceName; + + _SamplingManager_getSamplingStrategy_args__isset __isset; + + void __set_serviceName(const std::string& val); + + bool operator == (const SamplingManager_getSamplingStrategy_args & rhs) const + { + if (!(serviceName == rhs.serviceName)) + return false; + return true; + } + bool operator != (const SamplingManager_getSamplingStrategy_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SamplingManager_getSamplingStrategy_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class SamplingManager_getSamplingStrategy_pargs { + public: + + + virtual ~SamplingManager_getSamplingStrategy_pargs() throw(); + const std::string* serviceName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _SamplingManager_getSamplingStrategy_result__isset { + _SamplingManager_getSamplingStrategy_result__isset() : success(false) {} + bool success :1; +} _SamplingManager_getSamplingStrategy_result__isset; + +class SamplingManager_getSamplingStrategy_result { + public: + + SamplingManager_getSamplingStrategy_result(const SamplingManager_getSamplingStrategy_result&); + SamplingManager_getSamplingStrategy_result& operator=(const SamplingManager_getSamplingStrategy_result&); + SamplingManager_getSamplingStrategy_result() { + } + + virtual ~SamplingManager_getSamplingStrategy_result() throw(); + SamplingStrategyResponse success; + + _SamplingManager_getSamplingStrategy_result__isset __isset; + + void __set_success(const SamplingStrategyResponse& val); + + bool operator == (const SamplingManager_getSamplingStrategy_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const SamplingManager_getSamplingStrategy_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SamplingManager_getSamplingStrategy_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _SamplingManager_getSamplingStrategy_presult__isset { + _SamplingManager_getSamplingStrategy_presult__isset() : success(false) {} + bool success :1; +} _SamplingManager_getSamplingStrategy_presult__isset; + +class SamplingManager_getSamplingStrategy_presult { + public: + + + virtual ~SamplingManager_getSamplingStrategy_presult() throw(); + SamplingStrategyResponse* success; + + _SamplingManager_getSamplingStrategy_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +class SamplingManagerClient : virtual public SamplingManagerIf { + public: + SamplingManagerClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + SamplingManagerClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName); + void send_getSamplingStrategy(const std::string& serviceName); + void recv_getSamplingStrategy(SamplingStrategyResponse& _return); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class SamplingManagerProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<SamplingManagerIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (SamplingManagerProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_getSamplingStrategy(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + SamplingManagerProcessor(::std::shared_ptr<SamplingManagerIf> iface) : + iface_(iface) { + processMap_["getSamplingStrategy"] = &SamplingManagerProcessor::process_getSamplingStrategy; + } + + virtual ~SamplingManagerProcessor() {} +}; + +class SamplingManagerProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + SamplingManagerProcessorFactory(const ::std::shared_ptr< SamplingManagerIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< SamplingManagerIfFactory > handlerFactory_; +}; + +class SamplingManagerMultiface : virtual public SamplingManagerIf { + public: + SamplingManagerMultiface(std::vector<std::shared_ptr<SamplingManagerIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~SamplingManagerMultiface() {} + protected: + std::vector<std::shared_ptr<SamplingManagerIf> > ifaces_; + SamplingManagerMultiface() {} + void add(::std::shared_ptr<SamplingManagerIf> iface) { + ifaces_.push_back(iface); + } + public: + void getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getSamplingStrategy(_return, serviceName); + } + ifaces_[i]->getSamplingStrategy(_return, serviceName); + return; + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class SamplingManagerConcurrentClient : virtual public SamplingManagerIf { + public: + SamplingManagerConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + SamplingManagerConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName); + int32_t send_getSamplingStrategy(const std::string& serviceName); + void recv_getSamplingStrategy(SamplingStrategyResponse& _return, const int32_t seqid); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.cpp new file mode 100644 index 000000000..d38e019c0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.cpp @@ -0,0 +1,804 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "TracedService.h" + +namespace jaegertracing { namespace crossdock { namespace thrift { + + +TracedService_startTrace_args::~TracedService_startTrace_args() throw() { +} + + +uint32_t TracedService_startTrace_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t TracedService_startTrace_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TracedService_startTrace_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +TracedService_startTrace_pargs::~TracedService_startTrace_pargs() throw() { +} + + +uint32_t TracedService_startTrace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TracedService_startTrace_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +TracedService_startTrace_result::~TracedService_startTrace_result() throw() { +} + + +uint32_t TracedService_startTrace_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t TracedService_startTrace_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("TracedService_startTrace_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +TracedService_startTrace_presult::~TracedService_startTrace_presult() throw() { +} + + +uint32_t TracedService_startTrace_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +TracedService_joinTrace_args::~TracedService_joinTrace_args() throw() { +} + + +uint32_t TracedService_joinTrace_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t TracedService_joinTrace_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TracedService_joinTrace_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +TracedService_joinTrace_pargs::~TracedService_joinTrace_pargs() throw() { +} + + +uint32_t TracedService_joinTrace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TracedService_joinTrace_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +TracedService_joinTrace_result::~TracedService_joinTrace_result() throw() { +} + + +uint32_t TracedService_joinTrace_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t TracedService_joinTrace_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("TracedService_joinTrace_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +TracedService_joinTrace_presult::~TracedService_joinTrace_presult() throw() { +} + + +uint32_t TracedService_joinTrace_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +void TracedServiceClient::startTrace(TraceResponse& _return, const StartTraceRequest& request) +{ + send_startTrace(request); + recv_startTrace(_return); +} + +void TracedServiceClient::send_startTrace(const StartTraceRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("startTrace", ::apache::thrift::protocol::T_CALL, cseqid); + + TracedService_startTrace_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void TracedServiceClient::recv_startTrace(TraceResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("startTrace") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + TracedService_startTrace_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "startTrace failed: unknown result"); +} + +void TracedServiceClient::joinTrace(TraceResponse& _return, const JoinTraceRequest& request) +{ + send_joinTrace(request); + recv_joinTrace(_return); +} + +void TracedServiceClient::send_joinTrace(const JoinTraceRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("joinTrace", ::apache::thrift::protocol::T_CALL, cseqid); + + TracedService_joinTrace_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void TracedServiceClient::recv_joinTrace(TraceResponse& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("joinTrace") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + TracedService_joinTrace_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "joinTrace failed: unknown result"); +} + +bool TracedServiceProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void TracedServiceProcessor::process_startTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("TracedService.startTrace", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "TracedService.startTrace"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "TracedService.startTrace"); + } + + TracedService_startTrace_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "TracedService.startTrace", bytes); + } + + TracedService_startTrace_result result; + try { + iface_->startTrace(result.success, args.request); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "TracedService.startTrace"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("startTrace", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "TracedService.startTrace"); + } + + oprot->writeMessageBegin("startTrace", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "TracedService.startTrace", bytes); + } +} + +void TracedServiceProcessor::process_joinTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("TracedService.joinTrace", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "TracedService.joinTrace"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "TracedService.joinTrace"); + } + + TracedService_joinTrace_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "TracedService.joinTrace", bytes); + } + + TracedService_joinTrace_result result; + try { + iface_->joinTrace(result.success, args.request); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "TracedService.joinTrace"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("joinTrace", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "TracedService.joinTrace"); + } + + oprot->writeMessageBegin("joinTrace", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "TracedService.joinTrace", bytes); + } +} + +::std::shared_ptr< ::apache::thrift::TProcessor > TracedServiceProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< TracedServiceIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< TracedServiceIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new TracedServiceProcessor(handler)); + return processor; +} + +void TracedServiceConcurrentClient::startTrace(TraceResponse& _return, const StartTraceRequest& request) +{ + int32_t seqid = send_startTrace(request); + recv_startTrace(_return, seqid); +} + +int32_t TracedServiceConcurrentClient::send_startTrace(const StartTraceRequest& request) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("startTrace", ::apache::thrift::protocol::T_CALL, cseqid); + + TracedService_startTrace_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void TracedServiceConcurrentClient::recv_startTrace(TraceResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("startTrace") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + TracedService_startTrace_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "startTrace failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void TracedServiceConcurrentClient::joinTrace(TraceResponse& _return, const JoinTraceRequest& request) +{ + int32_t seqid = send_joinTrace(request); + recv_joinTrace(_return, seqid); +} + +int32_t TracedServiceConcurrentClient::send_joinTrace(const JoinTraceRequest& request) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("joinTrace", ::apache::thrift::protocol::T_CALL, cseqid); + + TracedService_joinTrace_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void TracedServiceConcurrentClient::recv_joinTrace(TraceResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("joinTrace") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + TracedService_joinTrace_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "joinTrace failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +}}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.h new file mode 100644 index 000000000..3da73420d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.h @@ -0,0 +1,422 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef TracedService_H +#define TracedService_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "tracetest_types.h" + +namespace jaegertracing { namespace crossdock { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class TracedServiceIf { + public: + virtual ~TracedServiceIf() {} + virtual void startTrace(TraceResponse& _return, const StartTraceRequest& request) = 0; + virtual void joinTrace(TraceResponse& _return, const JoinTraceRequest& request) = 0; +}; + +class TracedServiceIfFactory { + public: + typedef TracedServiceIf Handler; + + virtual ~TracedServiceIfFactory() {} + + virtual TracedServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(TracedServiceIf* /* handler */) = 0; +}; + +class TracedServiceIfSingletonFactory : virtual public TracedServiceIfFactory { + public: + TracedServiceIfSingletonFactory(const ::std::shared_ptr<TracedServiceIf>& iface) : iface_(iface) {} + virtual ~TracedServiceIfSingletonFactory() {} + + virtual TracedServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(TracedServiceIf* /* handler */) {} + + protected: + ::std::shared_ptr<TracedServiceIf> iface_; +}; + +class TracedServiceNull : virtual public TracedServiceIf { + public: + virtual ~TracedServiceNull() {} + void startTrace(TraceResponse& /* _return */, const StartTraceRequest& /* request */) { + return; + } + void joinTrace(TraceResponse& /* _return */, const JoinTraceRequest& /* request */) { + return; + } +}; + +typedef struct _TracedService_startTrace_args__isset { + _TracedService_startTrace_args__isset() : request(false) {} + bool request :1; +} _TracedService_startTrace_args__isset; + +class TracedService_startTrace_args { + public: + + TracedService_startTrace_args(const TracedService_startTrace_args&); + TracedService_startTrace_args& operator=(const TracedService_startTrace_args&); + TracedService_startTrace_args() { + } + + virtual ~TracedService_startTrace_args() throw(); + StartTraceRequest request; + + _TracedService_startTrace_args__isset __isset; + + void __set_request(const StartTraceRequest& val); + + bool operator == (const TracedService_startTrace_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const TracedService_startTrace_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TracedService_startTrace_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class TracedService_startTrace_pargs { + public: + + + virtual ~TracedService_startTrace_pargs() throw(); + const StartTraceRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _TracedService_startTrace_result__isset { + _TracedService_startTrace_result__isset() : success(false) {} + bool success :1; +} _TracedService_startTrace_result__isset; + +class TracedService_startTrace_result { + public: + + TracedService_startTrace_result(const TracedService_startTrace_result&); + TracedService_startTrace_result& operator=(const TracedService_startTrace_result&); + TracedService_startTrace_result() { + } + + virtual ~TracedService_startTrace_result() throw(); + TraceResponse success; + + _TracedService_startTrace_result__isset __isset; + + void __set_success(const TraceResponse& val); + + bool operator == (const TracedService_startTrace_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TracedService_startTrace_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TracedService_startTrace_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _TracedService_startTrace_presult__isset { + _TracedService_startTrace_presult__isset() : success(false) {} + bool success :1; +} _TracedService_startTrace_presult__isset; + +class TracedService_startTrace_presult { + public: + + + virtual ~TracedService_startTrace_presult() throw(); + TraceResponse* success; + + _TracedService_startTrace_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _TracedService_joinTrace_args__isset { + _TracedService_joinTrace_args__isset() : request(false) {} + bool request :1; +} _TracedService_joinTrace_args__isset; + +class TracedService_joinTrace_args { + public: + + TracedService_joinTrace_args(const TracedService_joinTrace_args&); + TracedService_joinTrace_args& operator=(const TracedService_joinTrace_args&); + TracedService_joinTrace_args() { + } + + virtual ~TracedService_joinTrace_args() throw(); + JoinTraceRequest request; + + _TracedService_joinTrace_args__isset __isset; + + void __set_request(const JoinTraceRequest& val); + + bool operator == (const TracedService_joinTrace_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const TracedService_joinTrace_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TracedService_joinTrace_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class TracedService_joinTrace_pargs { + public: + + + virtual ~TracedService_joinTrace_pargs() throw(); + const JoinTraceRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _TracedService_joinTrace_result__isset { + _TracedService_joinTrace_result__isset() : success(false) {} + bool success :1; +} _TracedService_joinTrace_result__isset; + +class TracedService_joinTrace_result { + public: + + TracedService_joinTrace_result(const TracedService_joinTrace_result&); + TracedService_joinTrace_result& operator=(const TracedService_joinTrace_result&); + TracedService_joinTrace_result() { + } + + virtual ~TracedService_joinTrace_result() throw(); + TraceResponse success; + + _TracedService_joinTrace_result__isset __isset; + + void __set_success(const TraceResponse& val); + + bool operator == (const TracedService_joinTrace_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TracedService_joinTrace_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TracedService_joinTrace_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _TracedService_joinTrace_presult__isset { + _TracedService_joinTrace_presult__isset() : success(false) {} + bool success :1; +} _TracedService_joinTrace_presult__isset; + +class TracedService_joinTrace_presult { + public: + + + virtual ~TracedService_joinTrace_presult() throw(); + TraceResponse* success; + + _TracedService_joinTrace_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +class TracedServiceClient : virtual public TracedServiceIf { + public: + TracedServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + TracedServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void startTrace(TraceResponse& _return, const StartTraceRequest& request); + void send_startTrace(const StartTraceRequest& request); + void recv_startTrace(TraceResponse& _return); + void joinTrace(TraceResponse& _return, const JoinTraceRequest& request); + void send_joinTrace(const JoinTraceRequest& request); + void recv_joinTrace(TraceResponse& _return); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class TracedServiceProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<TracedServiceIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (TracedServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_startTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_joinTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + TracedServiceProcessor(::std::shared_ptr<TracedServiceIf> iface) : + iface_(iface) { + processMap_["startTrace"] = &TracedServiceProcessor::process_startTrace; + processMap_["joinTrace"] = &TracedServiceProcessor::process_joinTrace; + } + + virtual ~TracedServiceProcessor() {} +}; + +class TracedServiceProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + TracedServiceProcessorFactory(const ::std::shared_ptr< TracedServiceIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< TracedServiceIfFactory > handlerFactory_; +}; + +class TracedServiceMultiface : virtual public TracedServiceIf { + public: + TracedServiceMultiface(std::vector<std::shared_ptr<TracedServiceIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~TracedServiceMultiface() {} + protected: + std::vector<std::shared_ptr<TracedServiceIf> > ifaces_; + TracedServiceMultiface() {} + void add(::std::shared_ptr<TracedServiceIf> iface) { + ifaces_.push_back(iface); + } + public: + void startTrace(TraceResponse& _return, const StartTraceRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->startTrace(_return, request); + } + ifaces_[i]->startTrace(_return, request); + return; + } + + void joinTrace(TraceResponse& _return, const JoinTraceRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->joinTrace(_return, request); + } + ifaces_[i]->joinTrace(_return, request); + return; + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class TracedServiceConcurrentClient : virtual public TracedServiceIf { + public: + TracedServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + TracedServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void startTrace(TraceResponse& _return, const StartTraceRequest& request); + int32_t send_startTrace(const StartTraceRequest& request); + void recv_startTrace(TraceResponse& _return, const int32_t seqid); + void joinTrace(TraceResponse& _return, const JoinTraceRequest& request); + int32_t send_joinTrace(const JoinTraceRequest& request); + void recv_joinTrace(TraceResponse& _return, const int32_t seqid); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/ZipkinCollector.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/ZipkinCollector.cpp new file mode 100644 index 000000000..035bd7095 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/ZipkinCollector.cpp @@ -0,0 +1,481 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "ZipkinCollector.h" + +namespace twitter { namespace zipkin { namespace thrift { + + +ZipkinCollector_submitZipkinBatch_args::~ZipkinCollector_submitZipkinBatch_args() throw() { +} + + +uint32_t ZipkinCollector_submitZipkinBatch_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->spans.clear(); + uint32_t _size23; + ::apache::thrift::protocol::TType _etype26; + xfer += iprot->readListBegin(_etype26, _size23); + this->spans.resize(_size23); + uint32_t _i27; + for (_i27 = 0; _i27 < _size23; ++_i27) + { + xfer += this->spans[_i27].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.spans = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ZipkinCollector_submitZipkinBatch_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ZipkinCollector_submitZipkinBatch_args"); + + xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->spans.size())); + std::vector<Span> ::const_iterator _iter28; + for (_iter28 = this->spans.begin(); _iter28 != this->spans.end(); ++_iter28) + { + xfer += (*_iter28).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ZipkinCollector_submitZipkinBatch_pargs::~ZipkinCollector_submitZipkinBatch_pargs() throw() { +} + + +uint32_t ZipkinCollector_submitZipkinBatch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ZipkinCollector_submitZipkinBatch_pargs"); + + xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->spans)).size())); + std::vector<Span> ::const_iterator _iter29; + for (_iter29 = (*(this->spans)).begin(); _iter29 != (*(this->spans)).end(); ++_iter29) + { + xfer += (*_iter29).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ZipkinCollector_submitZipkinBatch_result::~ZipkinCollector_submitZipkinBatch_result() throw() { +} + + +uint32_t ZipkinCollector_submitZipkinBatch_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size30; + ::apache::thrift::protocol::TType _etype33; + xfer += iprot->readListBegin(_etype33, _size30); + this->success.resize(_size30); + uint32_t _i34; + for (_i34 = 0; _i34 < _size30; ++_i34) + { + xfer += this->success[_i34].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ZipkinCollector_submitZipkinBatch_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ZipkinCollector_submitZipkinBatch_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); + std::vector<Response> ::const_iterator _iter35; + for (_iter35 = this->success.begin(); _iter35 != this->success.end(); ++_iter35) + { + xfer += (*_iter35).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ZipkinCollector_submitZipkinBatch_presult::~ZipkinCollector_submitZipkinBatch_presult() throw() { +} + + +uint32_t ZipkinCollector_submitZipkinBatch_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size36; + ::apache::thrift::protocol::TType _etype39; + xfer += iprot->readListBegin(_etype39, _size36); + (*(this->success)).resize(_size36); + uint32_t _i40; + for (_i40 = 0; _i40 < _size36; ++_i40) + { + xfer += (*(this->success))[_i40].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +void ZipkinCollectorClient::submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) +{ + send_submitZipkinBatch(spans); + recv_submitZipkinBatch(_return); +} + +void ZipkinCollectorClient::send_submitZipkinBatch(const std::vector<Span> & spans) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("submitZipkinBatch", ::apache::thrift::protocol::T_CALL, cseqid); + + ZipkinCollector_submitZipkinBatch_pargs args; + args.spans = &spans; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ZipkinCollectorClient::recv_submitZipkinBatch(std::vector<Response> & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("submitZipkinBatch") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ZipkinCollector_submitZipkinBatch_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submitZipkinBatch failed: unknown result"); +} + +bool ZipkinCollectorProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { + ProcessMap::iterator pfn; + pfn = processMap_.find(fname); + if (pfn == processMap_.end()) { + iprot->skip(::apache::thrift::protocol::T_STRUCT); + iprot->readMessageEnd(); + iprot->getTransport()->readEnd(); + ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'"); + oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return true; + } + (this->*(pfn->second))(seqid, iprot, oprot, callContext); + return true; +} + +void ZipkinCollectorProcessor::process_submitZipkinBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ZipkinCollector.submitZipkinBatch", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ZipkinCollector.submitZipkinBatch"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ZipkinCollector.submitZipkinBatch"); + } + + ZipkinCollector_submitZipkinBatch_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ZipkinCollector.submitZipkinBatch", bytes); + } + + ZipkinCollector_submitZipkinBatch_result result; + try { + iface_->submitZipkinBatch(result.success, args.spans); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ZipkinCollector.submitZipkinBatch"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("submitZipkinBatch", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ZipkinCollector.submitZipkinBatch"); + } + + oprot->writeMessageBegin("submitZipkinBatch", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ZipkinCollector.submitZipkinBatch", bytes); + } +} + +::std::shared_ptr< ::apache::thrift::TProcessor > ZipkinCollectorProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { + ::apache::thrift::ReleaseHandler< ZipkinCollectorIfFactory > cleanup(handlerFactory_); + ::std::shared_ptr< ZipkinCollectorIf > handler(handlerFactory_->getHandler(connInfo), cleanup); + ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new ZipkinCollectorProcessor(handler)); + return processor; +} + +void ZipkinCollectorConcurrentClient::submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) +{ + int32_t seqid = send_submitZipkinBatch(spans); + recv_submitZipkinBatch(_return, seqid); +} + +int32_t ZipkinCollectorConcurrentClient::send_submitZipkinBatch(const std::vector<Span> & spans) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("submitZipkinBatch", ::apache::thrift::protocol::T_CALL, cseqid); + + ZipkinCollector_submitZipkinBatch_pargs args; + args.spans = &spans; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ZipkinCollectorConcurrentClient::recv_submitZipkinBatch(std::vector<Response> & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("submitZipkinBatch") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ZipkinCollector_submitZipkinBatch_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submitZipkinBatch failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +}}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/ZipkinCollector.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/ZipkinCollector.h new file mode 100644 index 000000000..005290ce6 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/ZipkinCollector.h @@ -0,0 +1,296 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef ZipkinCollector_H +#define ZipkinCollector_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "zipkincore_types.h" + +namespace twitter { namespace zipkin { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class ZipkinCollectorIf { + public: + virtual ~ZipkinCollectorIf() {} + virtual void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) = 0; +}; + +class ZipkinCollectorIfFactory { + public: + typedef ZipkinCollectorIf Handler; + + virtual ~ZipkinCollectorIfFactory() {} + + virtual ZipkinCollectorIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(ZipkinCollectorIf* /* handler */) = 0; +}; + +class ZipkinCollectorIfSingletonFactory : virtual public ZipkinCollectorIfFactory { + public: + ZipkinCollectorIfSingletonFactory(const ::std::shared_ptr<ZipkinCollectorIf>& iface) : iface_(iface) {} + virtual ~ZipkinCollectorIfSingletonFactory() {} + + virtual ZipkinCollectorIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(ZipkinCollectorIf* /* handler */) {} + + protected: + ::std::shared_ptr<ZipkinCollectorIf> iface_; +}; + +class ZipkinCollectorNull : virtual public ZipkinCollectorIf { + public: + virtual ~ZipkinCollectorNull() {} + void submitZipkinBatch(std::vector<Response> & /* _return */, const std::vector<Span> & /* spans */) { + return; + } +}; + +typedef struct _ZipkinCollector_submitZipkinBatch_args__isset { + _ZipkinCollector_submitZipkinBatch_args__isset() : spans(false) {} + bool spans :1; +} _ZipkinCollector_submitZipkinBatch_args__isset; + +class ZipkinCollector_submitZipkinBatch_args { + public: + + ZipkinCollector_submitZipkinBatch_args(const ZipkinCollector_submitZipkinBatch_args&); + ZipkinCollector_submitZipkinBatch_args& operator=(const ZipkinCollector_submitZipkinBatch_args&); + ZipkinCollector_submitZipkinBatch_args() { + } + + virtual ~ZipkinCollector_submitZipkinBatch_args() throw(); + std::vector<Span> spans; + + _ZipkinCollector_submitZipkinBatch_args__isset __isset; + + void __set_spans(const std::vector<Span> & val); + + bool operator == (const ZipkinCollector_submitZipkinBatch_args & rhs) const + { + if (!(spans == rhs.spans)) + return false; + return true; + } + bool operator != (const ZipkinCollector_submitZipkinBatch_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ZipkinCollector_submitZipkinBatch_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ZipkinCollector_submitZipkinBatch_pargs { + public: + + + virtual ~ZipkinCollector_submitZipkinBatch_pargs() throw(); + const std::vector<Span> * spans; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ZipkinCollector_submitZipkinBatch_result__isset { + _ZipkinCollector_submitZipkinBatch_result__isset() : success(false) {} + bool success :1; +} _ZipkinCollector_submitZipkinBatch_result__isset; + +class ZipkinCollector_submitZipkinBatch_result { + public: + + ZipkinCollector_submitZipkinBatch_result(const ZipkinCollector_submitZipkinBatch_result&); + ZipkinCollector_submitZipkinBatch_result& operator=(const ZipkinCollector_submitZipkinBatch_result&); + ZipkinCollector_submitZipkinBatch_result() { + } + + virtual ~ZipkinCollector_submitZipkinBatch_result() throw(); + std::vector<Response> success; + + _ZipkinCollector_submitZipkinBatch_result__isset __isset; + + void __set_success(const std::vector<Response> & val); + + bool operator == (const ZipkinCollector_submitZipkinBatch_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const ZipkinCollector_submitZipkinBatch_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ZipkinCollector_submitZipkinBatch_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ZipkinCollector_submitZipkinBatch_presult__isset { + _ZipkinCollector_submitZipkinBatch_presult__isset() : success(false) {} + bool success :1; +} _ZipkinCollector_submitZipkinBatch_presult__isset; + +class ZipkinCollector_submitZipkinBatch_presult { + public: + + + virtual ~ZipkinCollector_submitZipkinBatch_presult() throw(); + std::vector<Response> * success; + + _ZipkinCollector_submitZipkinBatch_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +class ZipkinCollectorClient : virtual public ZipkinCollectorIf { + public: + ZipkinCollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + ZipkinCollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans); + void send_submitZipkinBatch(const std::vector<Span> & spans); + void recv_submitZipkinBatch(std::vector<Response> & _return); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class ZipkinCollectorProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<ZipkinCollectorIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (ZipkinCollectorProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_submitZipkinBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + ZipkinCollectorProcessor(::std::shared_ptr<ZipkinCollectorIf> iface) : + iface_(iface) { + processMap_["submitZipkinBatch"] = &ZipkinCollectorProcessor::process_submitZipkinBatch; + } + + virtual ~ZipkinCollectorProcessor() {} +}; + +class ZipkinCollectorProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + ZipkinCollectorProcessorFactory(const ::std::shared_ptr< ZipkinCollectorIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< ZipkinCollectorIfFactory > handlerFactory_; +}; + +class ZipkinCollectorMultiface : virtual public ZipkinCollectorIf { + public: + ZipkinCollectorMultiface(std::vector<std::shared_ptr<ZipkinCollectorIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~ZipkinCollectorMultiface() {} + protected: + std::vector<std::shared_ptr<ZipkinCollectorIf> > ifaces_; + ZipkinCollectorMultiface() {} + void add(::std::shared_ptr<ZipkinCollectorIf> iface) { + ifaces_.push_back(iface); + } + public: + void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->submitZipkinBatch(_return, spans); + } + ifaces_[i]->submitZipkinBatch(_return, spans); + return; + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class ZipkinCollectorConcurrentClient : virtual public ZipkinCollectorIf { + public: + ZipkinCollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + ZipkinCollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans); + int32_t send_submitZipkinBatch(const std::vector<Span> & spans); + void recv_submitZipkinBatch(std::vector<Response> & _return, const int32_t seqid); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_constants.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_constants.cpp new file mode 100644 index 000000000..f6a9d94ef --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_constants.cpp @@ -0,0 +1,17 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "agent_constants.h" + +namespace jaegertracing { namespace agent { namespace thrift { + +const agentConstants g_agent_constants; + +agentConstants::agentConstants() { +} + +}}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_constants.h new file mode 100644 index 000000000..31302545f --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_constants.h @@ -0,0 +1,24 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef agent_CONSTANTS_H +#define agent_CONSTANTS_H + +#include "agent_types.h" + +namespace jaegertracing { namespace agent { namespace thrift { + +class agentConstants { + public: + agentConstants(); + +}; + +extern const agentConstants g_agent_constants; + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_types.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_types.cpp new file mode 100644 index 000000000..c06f58dc0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_types.cpp @@ -0,0 +1,16 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "agent_types.h" + +#include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> + +namespace jaegertracing { namespace agent { namespace thrift { + +}}} // namespace diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_types.h new file mode 100644 index 000000000..772f3c1ab --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/agent_types.h @@ -0,0 +1,26 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef agent_TYPES_H +#define agent_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/TBase.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + +#include "jaeger_types.h" +#include "zipkincore_types.h" + + +namespace jaegertracing { namespace agent { namespace thrift { + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_constants.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_constants.cpp new file mode 100644 index 000000000..727fcd22e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_constants.cpp @@ -0,0 +1,17 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "aggregation_validator_constants.h" + +namespace jaegertracing { namespace thrift { + +const aggregation_validatorConstants g_aggregation_validator_constants; + +aggregation_validatorConstants::aggregation_validatorConstants() { +} + +}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_constants.h new file mode 100644 index 000000000..45d93b64d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_constants.h @@ -0,0 +1,24 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef aggregation_validator_CONSTANTS_H +#define aggregation_validator_CONSTANTS_H + +#include "aggregation_validator_types.h" + +namespace jaegertracing { namespace thrift { + +class aggregation_validatorConstants { + public: + aggregation_validatorConstants(); + +}; + +extern const aggregation_validatorConstants g_aggregation_validator_constants; + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_types.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_types.cpp new file mode 100644 index 000000000..85454e87e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_types.cpp @@ -0,0 +1,131 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "aggregation_validator_types.h" + +#include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> + +namespace jaegertracing { namespace thrift { + + +ValidateTraceResponse::~ValidateTraceResponse() throw() { +} + + +void ValidateTraceResponse::__set_ok(const bool val) { + this->ok = val; +} + +void ValidateTraceResponse::__set_traceCount(const int64_t val) { + this->traceCount = val; +} +std::ostream& operator<<(std::ostream& out, const ValidateTraceResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ValidateTraceResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_ok = false; + bool isset_traceCount = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ok); + isset_ok = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->traceCount); + isset_traceCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_ok) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_traceCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ValidateTraceResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ValidateTraceResponse"); + + xfer += oprot->writeFieldBegin("ok", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->ok); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("traceCount", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->traceCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ValidateTraceResponse &a, ValidateTraceResponse &b) { + using ::std::swap; + swap(a.ok, b.ok); + swap(a.traceCount, b.traceCount); +} + +ValidateTraceResponse::ValidateTraceResponse(const ValidateTraceResponse& other0) { + ok = other0.ok; + traceCount = other0.traceCount; +} +ValidateTraceResponse& ValidateTraceResponse::operator=(const ValidateTraceResponse& other1) { + ok = other1.ok; + traceCount = other1.traceCount; + return *this; +} +void ValidateTraceResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ValidateTraceResponse("; + out << "ok=" << to_string(ok); + out << ", " << "traceCount=" << to_string(traceCount); + out << ")"; +} + +}} // namespace diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_types.h new file mode 100644 index 000000000..26b943289 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/aggregation_validator_types.h @@ -0,0 +1,68 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef aggregation_validator_TYPES_H +#define aggregation_validator_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/TBase.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + + + + +namespace jaegertracing { namespace thrift { + +class ValidateTraceResponse; + + +class ValidateTraceResponse : public virtual ::apache::thrift::TBase { + public: + + ValidateTraceResponse(const ValidateTraceResponse&); + ValidateTraceResponse& operator=(const ValidateTraceResponse&); + ValidateTraceResponse() : ok(0), traceCount(0) { + } + + virtual ~ValidateTraceResponse() throw(); + bool ok; + int64_t traceCount; + + void __set_ok(const bool val); + + void __set_traceCount(const int64_t val); + + bool operator == (const ValidateTraceResponse & rhs) const + { + if (!(ok == rhs.ok)) + return false; + if (!(traceCount == rhs.traceCount)) + return false; + return true; + } + bool operator != (const ValidateTraceResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ValidateTraceResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ValidateTraceResponse &a, ValidateTraceResponse &b); + +std::ostream& operator<<(std::ostream& out, const ValidateTraceResponse& obj); + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_constants.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_constants.cpp new file mode 100644 index 000000000..1d5b2ffa8 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_constants.cpp @@ -0,0 +1,17 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "baggage_constants.h" + +namespace jaegertracing { namespace thrift { + +const baggageConstants g_baggage_constants; + +baggageConstants::baggageConstants() { +} + +}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_constants.h new file mode 100644 index 000000000..985347140 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_constants.h @@ -0,0 +1,24 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef baggage_CONSTANTS_H +#define baggage_CONSTANTS_H + +#include "baggage_types.h" + +namespace jaegertracing { namespace thrift { + +class baggageConstants { + public: + baggageConstants(); + +}; + +extern const baggageConstants g_baggage_constants; + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_types.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_types.cpp new file mode 100644 index 000000000..73b8526bc --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_types.cpp @@ -0,0 +1,131 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "baggage_types.h" + +#include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> + +namespace jaegertracing { namespace thrift { + + +BaggageRestriction::~BaggageRestriction() throw() { +} + + +void BaggageRestriction::__set_baggageKey(const std::string& val) { + this->baggageKey = val; +} + +void BaggageRestriction::__set_maxValueLength(const int32_t val) { + this->maxValueLength = val; +} +std::ostream& operator<<(std::ostream& out, const BaggageRestriction& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t BaggageRestriction::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_baggageKey = false; + bool isset_maxValueLength = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->baggageKey); + isset_baggageKey = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->maxValueLength); + isset_maxValueLength = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_baggageKey) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_maxValueLength) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t BaggageRestriction::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("BaggageRestriction"); + + xfer += oprot->writeFieldBegin("baggageKey", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->baggageKey); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("maxValueLength", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->maxValueLength); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(BaggageRestriction &a, BaggageRestriction &b) { + using ::std::swap; + swap(a.baggageKey, b.baggageKey); + swap(a.maxValueLength, b.maxValueLength); +} + +BaggageRestriction::BaggageRestriction(const BaggageRestriction& other0) { + baggageKey = other0.baggageKey; + maxValueLength = other0.maxValueLength; +} +BaggageRestriction& BaggageRestriction::operator=(const BaggageRestriction& other1) { + baggageKey = other1.baggageKey; + maxValueLength = other1.maxValueLength; + return *this; +} +void BaggageRestriction::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "BaggageRestriction("; + out << "baggageKey=" << to_string(baggageKey); + out << ", " << "maxValueLength=" << to_string(maxValueLength); + out << ")"; +} + +}} // namespace diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_types.h new file mode 100644 index 000000000..934b17304 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/baggage_types.h @@ -0,0 +1,68 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef baggage_TYPES_H +#define baggage_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/TBase.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + + + + +namespace jaegertracing { namespace thrift { + +class BaggageRestriction; + + +class BaggageRestriction : public virtual ::apache::thrift::TBase { + public: + + BaggageRestriction(const BaggageRestriction&); + BaggageRestriction& operator=(const BaggageRestriction&); + BaggageRestriction() : baggageKey(), maxValueLength(0) { + } + + virtual ~BaggageRestriction() throw(); + std::string baggageKey; + int32_t maxValueLength; + + void __set_baggageKey(const std::string& val); + + void __set_maxValueLength(const int32_t val); + + bool operator == (const BaggageRestriction & rhs) const + { + if (!(baggageKey == rhs.baggageKey)) + return false; + if (!(maxValueLength == rhs.maxValueLength)) + return false; + return true; + } + bool operator != (const BaggageRestriction &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BaggageRestriction & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(BaggageRestriction &a, BaggageRestriction &b); + +std::ostream& operator<<(std::ostream& out, const BaggageRestriction& obj); + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_constants.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_constants.cpp new file mode 100644 index 000000000..fcfb77fb2 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_constants.cpp @@ -0,0 +1,17 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "dependency_constants.h" + +namespace jaegertracing { namespace thrift { + +const dependencyConstants g_dependency_constants; + +dependencyConstants::dependencyConstants() { +} + +}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_constants.h new file mode 100644 index 000000000..bc7a0f7d1 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_constants.h @@ -0,0 +1,24 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef dependency_CONSTANTS_H +#define dependency_CONSTANTS_H + +#include "dependency_types.h" + +namespace jaegertracing { namespace thrift { + +class dependencyConstants { + public: + dependencyConstants(); + +}; + +extern const dependencyConstants g_dependency_constants; + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_types.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_types.cpp new file mode 100644 index 000000000..65fb208fc --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_types.cpp @@ -0,0 +1,266 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "dependency_types.h" + +#include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> + +namespace jaegertracing { namespace thrift { + + +DependencyLink::~DependencyLink() throw() { +} + + +void DependencyLink::__set_parent(const std::string& val) { + this->parent = val; +} + +void DependencyLink::__set_child(const std::string& val) { + this->child = val; +} + +void DependencyLink::__set_callCount(const int64_t val) { + this->callCount = val; +} +std::ostream& operator<<(std::ostream& out, const DependencyLink& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t DependencyLink::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_parent = false; + bool isset_child = false; + bool isset_callCount = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->parent); + isset_parent = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->child); + isset_child = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->callCount); + isset_callCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_parent) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_child) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_callCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DependencyLink::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DependencyLink"); + + xfer += oprot->writeFieldBegin("parent", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->parent); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("child", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->child); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("callCount", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->callCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DependencyLink &a, DependencyLink &b) { + using ::std::swap; + swap(a.parent, b.parent); + swap(a.child, b.child); + swap(a.callCount, b.callCount); +} + +DependencyLink::DependencyLink(const DependencyLink& other0) { + parent = other0.parent; + child = other0.child; + callCount = other0.callCount; +} +DependencyLink& DependencyLink::operator=(const DependencyLink& other1) { + parent = other1.parent; + child = other1.child; + callCount = other1.callCount; + return *this; +} +void DependencyLink::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DependencyLink("; + out << "parent=" << to_string(parent); + out << ", " << "child=" << to_string(child); + out << ", " << "callCount=" << to_string(callCount); + out << ")"; +} + + +Dependencies::~Dependencies() throw() { +} + + +void Dependencies::__set_links(const std::vector<DependencyLink> & val) { + this->links = val; +} +std::ostream& operator<<(std::ostream& out, const Dependencies& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Dependencies::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_links = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->links.clear(); + uint32_t _size2; + ::apache::thrift::protocol::TType _etype5; + xfer += iprot->readListBegin(_etype5, _size2); + this->links.resize(_size2); + uint32_t _i6; + for (_i6 = 0; _i6 < _size2; ++_i6) + { + xfer += this->links[_i6].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_links = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_links) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Dependencies::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Dependencies"); + + xfer += oprot->writeFieldBegin("links", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->links.size())); + std::vector<DependencyLink> ::const_iterator _iter7; + for (_iter7 = this->links.begin(); _iter7 != this->links.end(); ++_iter7) + { + xfer += (*_iter7).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Dependencies &a, Dependencies &b) { + using ::std::swap; + swap(a.links, b.links); +} + +Dependencies::Dependencies(const Dependencies& other8) { + links = other8.links; +} +Dependencies& Dependencies::operator=(const Dependencies& other9) { + links = other9.links; + return *this; +} +void Dependencies::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Dependencies("; + out << "links=" << to_string(links); + out << ")"; +} + +}} // namespace diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_types.h new file mode 100644 index 000000000..3361ea01a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/dependency_types.h @@ -0,0 +1,111 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef dependency_TYPES_H +#define dependency_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/TBase.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + + + + +namespace jaegertracing { namespace thrift { + +class DependencyLink; + +class Dependencies; + + +class DependencyLink : public virtual ::apache::thrift::TBase { + public: + + DependencyLink(const DependencyLink&); + DependencyLink& operator=(const DependencyLink&); + DependencyLink() : parent(), child(), callCount(0) { + } + + virtual ~DependencyLink() throw(); + std::string parent; + std::string child; + int64_t callCount; + + void __set_parent(const std::string& val); + + void __set_child(const std::string& val); + + void __set_callCount(const int64_t val); + + bool operator == (const DependencyLink & rhs) const + { + if (!(parent == rhs.parent)) + return false; + if (!(child == rhs.child)) + return false; + if (!(callCount == rhs.callCount)) + return false; + return true; + } + bool operator != (const DependencyLink &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DependencyLink & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(DependencyLink &a, DependencyLink &b); + +std::ostream& operator<<(std::ostream& out, const DependencyLink& obj); + + +class Dependencies : public virtual ::apache::thrift::TBase { + public: + + Dependencies(const Dependencies&); + Dependencies& operator=(const Dependencies&); + Dependencies() { + } + + virtual ~Dependencies() throw(); + std::vector<DependencyLink> links; + + void __set_links(const std::vector<DependencyLink> & val); + + bool operator == (const Dependencies & rhs) const + { + if (!(links == rhs.links)) + return false; + return true; + } + bool operator != (const Dependencies &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Dependencies & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Dependencies &a, Dependencies &b); + +std::ostream& operator<<(std::ostream& out, const Dependencies& obj); + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_constants.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_constants.cpp new file mode 100644 index 000000000..97ed94305 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_constants.cpp @@ -0,0 +1,17 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "jaeger_constants.h" + +namespace jaegertracing { namespace thrift { + +const jaegerConstants g_jaeger_constants; + +jaegerConstants::jaegerConstants() { +} + +}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_constants.h new file mode 100644 index 000000000..dc857da11 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_constants.h @@ -0,0 +1,24 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef jaeger_CONSTANTS_H +#define jaeger_CONSTANTS_H + +#include "jaeger_types.h" + +namespace jaegertracing { namespace thrift { + +class jaegerConstants { + public: + jaegerConstants(); + +}; + +extern const jaegerConstants g_jaeger_constants; + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.cpp new file mode 100644 index 000000000..eaac975a1 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.cpp @@ -0,0 +1,1336 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "jaeger_types.h" + +#include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> + +namespace jaegertracing { namespace thrift { + +int _kTagTypeValues[] = { + TagType::STRING, + TagType::DOUBLE, + TagType::BOOL, + TagType::LONG, + TagType::BINARY +}; +const char* _kTagTypeNames[] = { + "STRING", + "DOUBLE", + "BOOL", + "LONG", + "BINARY" +}; +const std::map<int, const char*> _TagType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kTagTypeValues, _kTagTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +std::ostream& operator<<(std::ostream& out, const TagType::type& val) { + std::map<int, const char*>::const_iterator it = _TagType_VALUES_TO_NAMES.find(val); + if (it != _TagType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast<int>(val); + } + return out; +} + +int _kSpanRefTypeValues[] = { + SpanRefType::CHILD_OF, + SpanRefType::FOLLOWS_FROM +}; +const char* _kSpanRefTypeNames[] = { + "CHILD_OF", + "FOLLOWS_FROM" +}; +const std::map<int, const char*> _SpanRefType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSpanRefTypeValues, _kSpanRefTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +std::ostream& operator<<(std::ostream& out, const SpanRefType::type& val) { + std::map<int, const char*>::const_iterator it = _SpanRefType_VALUES_TO_NAMES.find(val); + if (it != _SpanRefType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast<int>(val); + } + return out; +} + + +Tag::~Tag() throw() { +} + + +void Tag::__set_key(const std::string& val) { + this->key = val; +} + +void Tag::__set_vType(const TagType::type val) { + this->vType = val; +} + +void Tag::__set_vStr(const std::string& val) { + this->vStr = val; +__isset.vStr = true; +} + +void Tag::__set_vDouble(const double val) { + this->vDouble = val; +__isset.vDouble = true; +} + +void Tag::__set_vBool(const bool val) { + this->vBool = val; +__isset.vBool = true; +} + +void Tag::__set_vLong(const int64_t val) { + this->vLong = val; +__isset.vLong = true; +} + +void Tag::__set_vBinary(const std::string& val) { + this->vBinary = val; +__isset.vBinary = true; +} +std::ostream& operator<<(std::ostream& out, const Tag& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Tag::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_key = false; + bool isset_vType = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + isset_key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast0; + xfer += iprot->readI32(ecast0); + this->vType = (TagType::type)ecast0; + isset_vType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->vStr); + this->__isset.vStr = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->vDouble); + this->__isset.vDouble = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->vBool); + this->__isset.vBool = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->vLong); + this->__isset.vLong = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->vBinary); + this->__isset.vBinary = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_key) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_vType) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Tag::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Tag"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("vType", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32((int32_t)this->vType); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.vStr) { + xfer += oprot->writeFieldBegin("vStr", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->vStr); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.vDouble) { + xfer += oprot->writeFieldBegin("vDouble", ::apache::thrift::protocol::T_DOUBLE, 4); + xfer += oprot->writeDouble(this->vDouble); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.vBool) { + xfer += oprot->writeFieldBegin("vBool", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->vBool); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.vLong) { + xfer += oprot->writeFieldBegin("vLong", ::apache::thrift::protocol::T_I64, 6); + xfer += oprot->writeI64(this->vLong); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.vBinary) { + xfer += oprot->writeFieldBegin("vBinary", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeBinary(this->vBinary); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Tag &a, Tag &b) { + using ::std::swap; + swap(a.key, b.key); + swap(a.vType, b.vType); + swap(a.vStr, b.vStr); + swap(a.vDouble, b.vDouble); + swap(a.vBool, b.vBool); + swap(a.vLong, b.vLong); + swap(a.vBinary, b.vBinary); + swap(a.__isset, b.__isset); +} + +Tag::Tag(const Tag& other1) { + key = other1.key; + vType = other1.vType; + vStr = other1.vStr; + vDouble = other1.vDouble; + vBool = other1.vBool; + vLong = other1.vLong; + vBinary = other1.vBinary; + __isset = other1.__isset; +} +Tag& Tag::operator=(const Tag& other2) { + key = other2.key; + vType = other2.vType; + vStr = other2.vStr; + vDouble = other2.vDouble; + vBool = other2.vBool; + vLong = other2.vLong; + vBinary = other2.vBinary; + __isset = other2.__isset; + return *this; +} +void Tag::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Tag("; + out << "key=" << to_string(key); + out << ", " << "vType=" << to_string(vType); + out << ", " << "vStr="; (__isset.vStr ? (out << to_string(vStr)) : (out << "<null>")); + out << ", " << "vDouble="; (__isset.vDouble ? (out << to_string(vDouble)) : (out << "<null>")); + out << ", " << "vBool="; (__isset.vBool ? (out << to_string(vBool)) : (out << "<null>")); + out << ", " << "vLong="; (__isset.vLong ? (out << to_string(vLong)) : (out << "<null>")); + out << ", " << "vBinary="; (__isset.vBinary ? (out << to_string(vBinary)) : (out << "<null>")); + out << ")"; +} + + +Log::~Log() throw() { +} + + +void Log::__set_timestamp(const int64_t val) { + this->timestamp = val; +} + +void Log::__set_fields(const std::vector<Tag> & val) { + this->fields = val; +} +std::ostream& operator<<(std::ostream& out, const Log& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Log::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_timestamp = false; + bool isset_fields = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->timestamp); + isset_timestamp = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fields.clear(); + uint32_t _size3; + ::apache::thrift::protocol::TType _etype6; + xfer += iprot->readListBegin(_etype6, _size3); + this->fields.resize(_size3); + uint32_t _i7; + for (_i7 = 0; _i7 < _size3; ++_i7) + { + xfer += this->fields[_i7].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_fields = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_timestamp) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_fields) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Log::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Log"); + + xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->timestamp); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->fields.size())); + std::vector<Tag> ::const_iterator _iter8; + for (_iter8 = this->fields.begin(); _iter8 != this->fields.end(); ++_iter8) + { + xfer += (*_iter8).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Log &a, Log &b) { + using ::std::swap; + swap(a.timestamp, b.timestamp); + swap(a.fields, b.fields); +} + +Log::Log(const Log& other9) { + timestamp = other9.timestamp; + fields = other9.fields; +} +Log& Log::operator=(const Log& other10) { + timestamp = other10.timestamp; + fields = other10.fields; + return *this; +} +void Log::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Log("; + out << "timestamp=" << to_string(timestamp); + out << ", " << "fields=" << to_string(fields); + out << ")"; +} + + +SpanRef::~SpanRef() throw() { +} + + +void SpanRef::__set_refType(const SpanRefType::type val) { + this->refType = val; +} + +void SpanRef::__set_traceIdLow(const int64_t val) { + this->traceIdLow = val; +} + +void SpanRef::__set_traceIdHigh(const int64_t val) { + this->traceIdHigh = val; +} + +void SpanRef::__set_spanId(const int64_t val) { + this->spanId = val; +} +std::ostream& operator<<(std::ostream& out, const SpanRef& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SpanRef::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_refType = false; + bool isset_traceIdLow = false; + bool isset_traceIdHigh = false; + bool isset_spanId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast11; + xfer += iprot->readI32(ecast11); + this->refType = (SpanRefType::type)ecast11; + isset_refType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->traceIdLow); + isset_traceIdLow = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->traceIdHigh); + isset_traceIdHigh = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->spanId); + isset_spanId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_refType) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_traceIdLow) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_traceIdHigh) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_spanId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SpanRef::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SpanRef"); + + xfer += oprot->writeFieldBegin("refType", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((int32_t)this->refType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("traceIdLow", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->traceIdLow); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("traceIdHigh", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->traceIdHigh); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("spanId", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->spanId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SpanRef &a, SpanRef &b) { + using ::std::swap; + swap(a.refType, b.refType); + swap(a.traceIdLow, b.traceIdLow); + swap(a.traceIdHigh, b.traceIdHigh); + swap(a.spanId, b.spanId); +} + +SpanRef::SpanRef(const SpanRef& other12) { + refType = other12.refType; + traceIdLow = other12.traceIdLow; + traceIdHigh = other12.traceIdHigh; + spanId = other12.spanId; +} +SpanRef& SpanRef::operator=(const SpanRef& other13) { + refType = other13.refType; + traceIdLow = other13.traceIdLow; + traceIdHigh = other13.traceIdHigh; + spanId = other13.spanId; + return *this; +} +void SpanRef::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SpanRef("; + out << "refType=" << to_string(refType); + out << ", " << "traceIdLow=" << to_string(traceIdLow); + out << ", " << "traceIdHigh=" << to_string(traceIdHigh); + out << ", " << "spanId=" << to_string(spanId); + out << ")"; +} + + +Span::~Span() throw() { +} + + +void Span::__set_traceIdLow(const int64_t val) { + this->traceIdLow = val; +} + +void Span::__set_traceIdHigh(const int64_t val) { + this->traceIdHigh = val; +} + +void Span::__set_spanId(const int64_t val) { + this->spanId = val; +} + +void Span::__set_parentSpanId(const int64_t val) { + this->parentSpanId = val; +} + +void Span::__set_operationName(const std::string& val) { + this->operationName = val; +} + +void Span::__set_references(const std::vector<SpanRef> & val) { + this->references = val; +__isset.references = true; +} + +void Span::__set_flags(const int32_t val) { + this->flags = val; +} + +void Span::__set_startTime(const int64_t val) { + this->startTime = val; +} + +void Span::__set_duration(const int64_t val) { + this->duration = val; +} + +void Span::__set_tags(const std::vector<Tag> & val) { + this->tags = val; +__isset.tags = true; +} + +void Span::__set_logs(const std::vector<Log> & val) { + this->logs = val; +__isset.logs = true; +} +std::ostream& operator<<(std::ostream& out, const Span& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Span::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_traceIdLow = false; + bool isset_traceIdHigh = false; + bool isset_spanId = false; + bool isset_parentSpanId = false; + bool isset_operationName = false; + bool isset_flags = false; + bool isset_startTime = false; + bool isset_duration = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->traceIdLow); + isset_traceIdLow = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->traceIdHigh); + isset_traceIdHigh = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->spanId); + isset_spanId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->parentSpanId); + isset_parentSpanId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->operationName); + isset_operationName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->references.clear(); + uint32_t _size14; + ::apache::thrift::protocol::TType _etype17; + xfer += iprot->readListBegin(_etype17, _size14); + this->references.resize(_size14); + uint32_t _i18; + for (_i18 = 0; _i18 < _size14; ++_i18) + { + xfer += this->references[_i18].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.references = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->flags); + isset_flags = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->startTime); + isset_startTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->duration); + isset_duration = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tags.clear(); + uint32_t _size19; + ::apache::thrift::protocol::TType _etype22; + xfer += iprot->readListBegin(_etype22, _size19); + this->tags.resize(_size19); + uint32_t _i23; + for (_i23 = 0; _i23 < _size19; ++_i23) + { + xfer += this->tags[_i23].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.tags = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->logs.clear(); + uint32_t _size24; + ::apache::thrift::protocol::TType _etype27; + xfer += iprot->readListBegin(_etype27, _size24); + this->logs.resize(_size24); + uint32_t _i28; + for (_i28 = 0; _i28 < _size24; ++_i28) + { + xfer += this->logs[_i28].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.logs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_traceIdLow) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_traceIdHigh) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_spanId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_parentSpanId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_operationName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_flags) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_startTime) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_duration) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Span::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Span"); + + xfer += oprot->writeFieldBegin("traceIdLow", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->traceIdLow); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("traceIdHigh", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->traceIdHigh); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("spanId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->spanId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parentSpanId", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->parentSpanId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("operationName", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->operationName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.references) { + xfer += oprot->writeFieldBegin("references", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->references.size())); + std::vector<SpanRef> ::const_iterator _iter29; + for (_iter29 = this->references.begin(); _iter29 != this->references.end(); ++_iter29) + { + xfer += (*_iter29).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("flags", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(this->flags); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("startTime", ::apache::thrift::protocol::T_I64, 8); + xfer += oprot->writeI64(this->startTime); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("duration", ::apache::thrift::protocol::T_I64, 9); + xfer += oprot->writeI64(this->duration); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.tags) { + xfer += oprot->writeFieldBegin("tags", ::apache::thrift::protocol::T_LIST, 10); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tags.size())); + std::vector<Tag> ::const_iterator _iter30; + for (_iter30 = this->tags.begin(); _iter30 != this->tags.end(); ++_iter30) + { + xfer += (*_iter30).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.logs) { + xfer += oprot->writeFieldBegin("logs", ::apache::thrift::protocol::T_LIST, 11); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->logs.size())); + std::vector<Log> ::const_iterator _iter31; + for (_iter31 = this->logs.begin(); _iter31 != this->logs.end(); ++_iter31) + { + xfer += (*_iter31).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Span &a, Span &b) { + using ::std::swap; + swap(a.traceIdLow, b.traceIdLow); + swap(a.traceIdHigh, b.traceIdHigh); + swap(a.spanId, b.spanId); + swap(a.parentSpanId, b.parentSpanId); + swap(a.operationName, b.operationName); + swap(a.references, b.references); + swap(a.flags, b.flags); + swap(a.startTime, b.startTime); + swap(a.duration, b.duration); + swap(a.tags, b.tags); + swap(a.logs, b.logs); + swap(a.__isset, b.__isset); +} + +Span::Span(const Span& other32) { + traceIdLow = other32.traceIdLow; + traceIdHigh = other32.traceIdHigh; + spanId = other32.spanId; + parentSpanId = other32.parentSpanId; + operationName = other32.operationName; + references = other32.references; + flags = other32.flags; + startTime = other32.startTime; + duration = other32.duration; + tags = other32.tags; + logs = other32.logs; + __isset = other32.__isset; +} +Span& Span::operator=(const Span& other33) { + traceIdLow = other33.traceIdLow; + traceIdHigh = other33.traceIdHigh; + spanId = other33.spanId; + parentSpanId = other33.parentSpanId; + operationName = other33.operationName; + references = other33.references; + flags = other33.flags; + startTime = other33.startTime; + duration = other33.duration; + tags = other33.tags; + logs = other33.logs; + __isset = other33.__isset; + return *this; +} +void Span::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Span("; + out << "traceIdLow=" << to_string(traceIdLow); + out << ", " << "traceIdHigh=" << to_string(traceIdHigh); + out << ", " << "spanId=" << to_string(spanId); + out << ", " << "parentSpanId=" << to_string(parentSpanId); + out << ", " << "operationName=" << to_string(operationName); + out << ", " << "references="; (__isset.references ? (out << to_string(references)) : (out << "<null>")); + out << ", " << "flags=" << to_string(flags); + out << ", " << "startTime=" << to_string(startTime); + out << ", " << "duration=" << to_string(duration); + out << ", " << "tags="; (__isset.tags ? (out << to_string(tags)) : (out << "<null>")); + out << ", " << "logs="; (__isset.logs ? (out << to_string(logs)) : (out << "<null>")); + out << ")"; +} + + +Process::~Process() throw() { +} + + +void Process::__set_serviceName(const std::string& val) { + this->serviceName = val; +} + +void Process::__set_tags(const std::vector<Tag> & val) { + this->tags = val; +__isset.tags = true; +} +std::ostream& operator<<(std::ostream& out, const Process& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Process::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_serviceName = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serviceName); + isset_serviceName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tags.clear(); + uint32_t _size34; + ::apache::thrift::protocol::TType _etype37; + xfer += iprot->readListBegin(_etype37, _size34); + this->tags.resize(_size34); + uint32_t _i38; + for (_i38 = 0; _i38 < _size34; ++_i38) + { + xfer += this->tags[_i38].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.tags = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_serviceName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Process::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Process"); + + xfer += oprot->writeFieldBegin("serviceName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->serviceName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.tags) { + xfer += oprot->writeFieldBegin("tags", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tags.size())); + std::vector<Tag> ::const_iterator _iter39; + for (_iter39 = this->tags.begin(); _iter39 != this->tags.end(); ++_iter39) + { + xfer += (*_iter39).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Process &a, Process &b) { + using ::std::swap; + swap(a.serviceName, b.serviceName); + swap(a.tags, b.tags); + swap(a.__isset, b.__isset); +} + +Process::Process(const Process& other40) { + serviceName = other40.serviceName; + tags = other40.tags; + __isset = other40.__isset; +} +Process& Process::operator=(const Process& other41) { + serviceName = other41.serviceName; + tags = other41.tags; + __isset = other41.__isset; + return *this; +} +void Process::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Process("; + out << "serviceName=" << to_string(serviceName); + out << ", " << "tags="; (__isset.tags ? (out << to_string(tags)) : (out << "<null>")); + out << ")"; +} + + +Batch::~Batch() throw() { +} + + +void Batch::__set_process(const Process& val) { + this->process = val; +} + +void Batch::__set_spans(const std::vector<Span> & val) { + this->spans = val; +} +std::ostream& operator<<(std::ostream& out, const Batch& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Batch::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_process = false; + bool isset_spans = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->process.read(iprot); + isset_process = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->spans.clear(); + uint32_t _size42; + ::apache::thrift::protocol::TType _etype45; + xfer += iprot->readListBegin(_etype45, _size42); + this->spans.resize(_size42); + uint32_t _i46; + for (_i46 = 0; _i46 < _size42; ++_i46) + { + xfer += this->spans[_i46].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_spans = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_process) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_spans) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Batch::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Batch"); + + xfer += oprot->writeFieldBegin("process", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->process.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->spans.size())); + std::vector<Span> ::const_iterator _iter47; + for (_iter47 = this->spans.begin(); _iter47 != this->spans.end(); ++_iter47) + { + xfer += (*_iter47).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Batch &a, Batch &b) { + using ::std::swap; + swap(a.process, b.process); + swap(a.spans, b.spans); +} + +Batch::Batch(const Batch& other48) { + process = other48.process; + spans = other48.spans; +} +Batch& Batch::operator=(const Batch& other49) { + process = other49.process; + spans = other49.spans; + return *this; +} +void Batch::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Batch("; + out << "process=" << to_string(process); + out << ", " << "spans=" << to_string(spans); + out << ")"; +} + + +BatchSubmitResponse::~BatchSubmitResponse() throw() { +} + + +void BatchSubmitResponse::__set_ok(const bool val) { + this->ok = val; +} +std::ostream& operator<<(std::ostream& out, const BatchSubmitResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t BatchSubmitResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_ok = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ok); + isset_ok = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_ok) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t BatchSubmitResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("BatchSubmitResponse"); + + xfer += oprot->writeFieldBegin("ok", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->ok); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(BatchSubmitResponse &a, BatchSubmitResponse &b) { + using ::std::swap; + swap(a.ok, b.ok); +} + +BatchSubmitResponse::BatchSubmitResponse(const BatchSubmitResponse& other50) { + ok = other50.ok; +} +BatchSubmitResponse& BatchSubmitResponse::operator=(const BatchSubmitResponse& other51) { + ok = other51.ok; + return *this; +} +void BatchSubmitResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "BatchSubmitResponse("; + out << "ok=" << to_string(ok); + out << ")"; +} + +}} // namespace diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.h new file mode 100644 index 000000000..6e8e7fba6 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.h @@ -0,0 +1,465 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef jaeger_TYPES_H +#define jaeger_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/TBase.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + +namespace jaegertracing { namespace thrift { + +struct TagType { + enum type { + STRING = 0, + DOUBLE = 1, + BOOL = 2, + LONG = 3, + BINARY = 4 + }; +}; + +extern const std::map<int, const char*> _TagType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const TagType::type& val); + +struct SpanRefType { + enum type { + CHILD_OF = 0, + FOLLOWS_FROM = 1 + }; +}; + +extern const std::map<int, const char*> _SpanRefType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const SpanRefType::type& val); + +class Tag; + +class Log; + +class SpanRef; + +class Span; + +class Process; + +class Batch; + +class BatchSubmitResponse; + +typedef struct _Tag__isset { + _Tag__isset() : vStr(false), vDouble(false), vBool(false), vLong(false), vBinary(false) {} + bool vStr :1; + bool vDouble :1; + bool vBool :1; + bool vLong :1; + bool vBinary :1; +} _Tag__isset; + +class Tag : public virtual ::apache::thrift::TBase { + public: + + Tag(const Tag&); + Tag& operator=(const Tag&); + Tag() : key(), vType((TagType::type)0), vStr(), vDouble(0), vBool(0), vLong(0), vBinary() { + } + + virtual ~Tag() throw(); + std::string key; + TagType::type vType; + std::string vStr; + double vDouble; + bool vBool; + int64_t vLong; + std::string vBinary; + + _Tag__isset __isset; + + void __set_key(const std::string& val); + + void __set_vType(const TagType::type val); + + void __set_vStr(const std::string& val); + + void __set_vDouble(const double val); + + void __set_vBool(const bool val); + + void __set_vLong(const int64_t val); + + void __set_vBinary(const std::string& val); + + bool operator == (const Tag & rhs) const + { + if (!(key == rhs.key)) + return false; + if (!(vType == rhs.vType)) + return false; + if (__isset.vStr != rhs.__isset.vStr) + return false; + else if (__isset.vStr && !(vStr == rhs.vStr)) + return false; + if (__isset.vDouble != rhs.__isset.vDouble) + return false; + else if (__isset.vDouble && !(vDouble == rhs.vDouble)) + return false; + if (__isset.vBool != rhs.__isset.vBool) + return false; + else if (__isset.vBool && !(vBool == rhs.vBool)) + return false; + if (__isset.vLong != rhs.__isset.vLong) + return false; + else if (__isset.vLong && !(vLong == rhs.vLong)) + return false; + if (__isset.vBinary != rhs.__isset.vBinary) + return false; + else if (__isset.vBinary && !(vBinary == rhs.vBinary)) + return false; + return true; + } + bool operator != (const Tag &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Tag & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Tag &a, Tag &b); + +std::ostream& operator<<(std::ostream& out, const Tag& obj); + + +class Log : public virtual ::apache::thrift::TBase { + public: + + Log(const Log&); + Log& operator=(const Log&); + Log() : timestamp(0) { + } + + virtual ~Log() throw(); + int64_t timestamp; + std::vector<Tag> fields; + + void __set_timestamp(const int64_t val); + + void __set_fields(const std::vector<Tag> & val); + + bool operator == (const Log & rhs) const + { + if (!(timestamp == rhs.timestamp)) + return false; + if (!(fields == rhs.fields)) + return false; + return true; + } + bool operator != (const Log &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Log & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Log &a, Log &b); + +std::ostream& operator<<(std::ostream& out, const Log& obj); + + +class SpanRef : public virtual ::apache::thrift::TBase { + public: + + SpanRef(const SpanRef&); + SpanRef& operator=(const SpanRef&); + SpanRef() : refType((SpanRefType::type)0), traceIdLow(0), traceIdHigh(0), spanId(0) { + } + + virtual ~SpanRef() throw(); + SpanRefType::type refType; + int64_t traceIdLow; + int64_t traceIdHigh; + int64_t spanId; + + void __set_refType(const SpanRefType::type val); + + void __set_traceIdLow(const int64_t val); + + void __set_traceIdHigh(const int64_t val); + + void __set_spanId(const int64_t val); + + bool operator == (const SpanRef & rhs) const + { + if (!(refType == rhs.refType)) + return false; + if (!(traceIdLow == rhs.traceIdLow)) + return false; + if (!(traceIdHigh == rhs.traceIdHigh)) + return false; + if (!(spanId == rhs.spanId)) + return false; + return true; + } + bool operator != (const SpanRef &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SpanRef & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SpanRef &a, SpanRef &b); + +std::ostream& operator<<(std::ostream& out, const SpanRef& obj); + +typedef struct _Span__isset { + _Span__isset() : references(false), tags(false), logs(false) {} + bool references :1; + bool tags :1; + bool logs :1; +} _Span__isset; + +class Span : public virtual ::apache::thrift::TBase { + public: + + Span(const Span&); + Span& operator=(const Span&); + Span() : traceIdLow(0), traceIdHigh(0), spanId(0), parentSpanId(0), operationName(), flags(0), startTime(0), duration(0) { + } + + virtual ~Span() throw(); + int64_t traceIdLow; + int64_t traceIdHigh; + int64_t spanId; + int64_t parentSpanId; + std::string operationName; + std::vector<SpanRef> references; + int32_t flags; + int64_t startTime; + int64_t duration; + std::vector<Tag> tags; + std::vector<Log> logs; + + _Span__isset __isset; + + void __set_traceIdLow(const int64_t val); + + void __set_traceIdHigh(const int64_t val); + + void __set_spanId(const int64_t val); + + void __set_parentSpanId(const int64_t val); + + void __set_operationName(const std::string& val); + + void __set_references(const std::vector<SpanRef> & val); + + void __set_flags(const int32_t val); + + void __set_startTime(const int64_t val); + + void __set_duration(const int64_t val); + + void __set_tags(const std::vector<Tag> & val); + + void __set_logs(const std::vector<Log> & val); + + bool operator == (const Span & rhs) const + { + if (!(traceIdLow == rhs.traceIdLow)) + return false; + if (!(traceIdHigh == rhs.traceIdHigh)) + return false; + if (!(spanId == rhs.spanId)) + return false; + if (!(parentSpanId == rhs.parentSpanId)) + return false; + if (!(operationName == rhs.operationName)) + return false; + if (__isset.references != rhs.__isset.references) + return false; + else if (__isset.references && !(references == rhs.references)) + return false; + if (!(flags == rhs.flags)) + return false; + if (!(startTime == rhs.startTime)) + return false; + if (!(duration == rhs.duration)) + return false; + if (__isset.tags != rhs.__isset.tags) + return false; + else if (__isset.tags && !(tags == rhs.tags)) + return false; + if (__isset.logs != rhs.__isset.logs) + return false; + else if (__isset.logs && !(logs == rhs.logs)) + return false; + return true; + } + bool operator != (const Span &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Span & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Span &a, Span &b); + +std::ostream& operator<<(std::ostream& out, const Span& obj); + +typedef struct _Process__isset { + _Process__isset() : tags(false) {} + bool tags :1; +} _Process__isset; + +class Process : public virtual ::apache::thrift::TBase { + public: + + Process(const Process&); + Process& operator=(const Process&); + Process() : serviceName() { + } + + virtual ~Process() throw(); + std::string serviceName; + std::vector<Tag> tags; + + _Process__isset __isset; + + void __set_serviceName(const std::string& val); + + void __set_tags(const std::vector<Tag> & val); + + bool operator == (const Process & rhs) const + { + if (!(serviceName == rhs.serviceName)) + return false; + if (__isset.tags != rhs.__isset.tags) + return false; + else if (__isset.tags && !(tags == rhs.tags)) + return false; + return true; + } + bool operator != (const Process &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Process & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Process &a, Process &b); + +std::ostream& operator<<(std::ostream& out, const Process& obj); + + +class Batch : public virtual ::apache::thrift::TBase { + public: + + Batch(const Batch&); + Batch& operator=(const Batch&); + Batch() { + } + + virtual ~Batch() throw(); + Process process; + std::vector<Span> spans; + + void __set_process(const Process& val); + + void __set_spans(const std::vector<Span> & val); + + bool operator == (const Batch & rhs) const + { + if (!(process == rhs.process)) + return false; + if (!(spans == rhs.spans)) + return false; + return true; + } + bool operator != (const Batch &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Batch & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Batch &a, Batch &b); + +std::ostream& operator<<(std::ostream& out, const Batch& obj); + + +class BatchSubmitResponse : public virtual ::apache::thrift::TBase { + public: + + BatchSubmitResponse(const BatchSubmitResponse&); + BatchSubmitResponse& operator=(const BatchSubmitResponse&); + BatchSubmitResponse() : ok(0) { + } + + virtual ~BatchSubmitResponse() throw(); + bool ok; + + void __set_ok(const bool val); + + bool operator == (const BatchSubmitResponse & rhs) const + { + if (!(ok == rhs.ok)) + return false; + return true; + } + bool operator != (const BatchSubmitResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BatchSubmitResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(BatchSubmitResponse &a, BatchSubmitResponse &b); + +std::ostream& operator<<(std::ostream& out, const BatchSubmitResponse& obj); + +}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_constants.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_constants.cpp new file mode 100644 index 000000000..02ea4941e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_constants.cpp @@ -0,0 +1,17 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "sampling_constants.h" + +namespace jaegertracing { namespace sampling_manager { namespace thrift { + +const samplingConstants g_sampling_constants; + +samplingConstants::samplingConstants() { +} + +}}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_constants.h new file mode 100644 index 000000000..94637e039 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_constants.h @@ -0,0 +1,24 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef sampling_CONSTANTS_H +#define sampling_CONSTANTS_H + +#include "sampling_types.h" + +namespace jaegertracing { namespace sampling_manager { namespace thrift { + +class samplingConstants { + public: + samplingConstants(); + +}; + +extern const samplingConstants g_sampling_constants; + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_types.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_types.cpp new file mode 100644 index 000000000..afde445bb --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_types.cpp @@ -0,0 +1,681 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "sampling_types.h" + +#include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> + +namespace jaegertracing { namespace sampling_manager { namespace thrift { + +int _kSamplingStrategyTypeValues[] = { + SamplingStrategyType::PROBABILISTIC, + SamplingStrategyType::RATE_LIMITING +}; +const char* _kSamplingStrategyTypeNames[] = { + "PROBABILISTIC", + "RATE_LIMITING" +}; +const std::map<int, const char*> _SamplingStrategyType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSamplingStrategyTypeValues, _kSamplingStrategyTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +std::ostream& operator<<(std::ostream& out, const SamplingStrategyType::type& val) { + std::map<int, const char*>::const_iterator it = _SamplingStrategyType_VALUES_TO_NAMES.find(val); + if (it != _SamplingStrategyType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast<int>(val); + } + return out; +} + + +ProbabilisticSamplingStrategy::~ProbabilisticSamplingStrategy() throw() { +} + + +void ProbabilisticSamplingStrategy::__set_samplingRate(const double val) { + this->samplingRate = val; +} +std::ostream& operator<<(std::ostream& out, const ProbabilisticSamplingStrategy& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ProbabilisticSamplingStrategy::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_samplingRate = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->samplingRate); + isset_samplingRate = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_samplingRate) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ProbabilisticSamplingStrategy::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ProbabilisticSamplingStrategy"); + + xfer += oprot->writeFieldBegin("samplingRate", ::apache::thrift::protocol::T_DOUBLE, 1); + xfer += oprot->writeDouble(this->samplingRate); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ProbabilisticSamplingStrategy &a, ProbabilisticSamplingStrategy &b) { + using ::std::swap; + swap(a.samplingRate, b.samplingRate); +} + +ProbabilisticSamplingStrategy::ProbabilisticSamplingStrategy(const ProbabilisticSamplingStrategy& other0) { + samplingRate = other0.samplingRate; +} +ProbabilisticSamplingStrategy& ProbabilisticSamplingStrategy::operator=(const ProbabilisticSamplingStrategy& other1) { + samplingRate = other1.samplingRate; + return *this; +} +void ProbabilisticSamplingStrategy::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ProbabilisticSamplingStrategy("; + out << "samplingRate=" << to_string(samplingRate); + out << ")"; +} + + +RateLimitingSamplingStrategy::~RateLimitingSamplingStrategy() throw() { +} + + +void RateLimitingSamplingStrategy::__set_maxTracesPerSecond(const int16_t val) { + this->maxTracesPerSecond = val; +} +std::ostream& operator<<(std::ostream& out, const RateLimitingSamplingStrategy& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t RateLimitingSamplingStrategy::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_maxTracesPerSecond = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->maxTracesPerSecond); + isset_maxTracesPerSecond = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_maxTracesPerSecond) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t RateLimitingSamplingStrategy::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("RateLimitingSamplingStrategy"); + + xfer += oprot->writeFieldBegin("maxTracesPerSecond", ::apache::thrift::protocol::T_I16, 1); + xfer += oprot->writeI16(this->maxTracesPerSecond); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(RateLimitingSamplingStrategy &a, RateLimitingSamplingStrategy &b) { + using ::std::swap; + swap(a.maxTracesPerSecond, b.maxTracesPerSecond); +} + +RateLimitingSamplingStrategy::RateLimitingSamplingStrategy(const RateLimitingSamplingStrategy& other2) { + maxTracesPerSecond = other2.maxTracesPerSecond; +} +RateLimitingSamplingStrategy& RateLimitingSamplingStrategy::operator=(const RateLimitingSamplingStrategy& other3) { + maxTracesPerSecond = other3.maxTracesPerSecond; + return *this; +} +void RateLimitingSamplingStrategy::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "RateLimitingSamplingStrategy("; + out << "maxTracesPerSecond=" << to_string(maxTracesPerSecond); + out << ")"; +} + + +OperationSamplingStrategy::~OperationSamplingStrategy() throw() { +} + + +void OperationSamplingStrategy::__set_operation(const std::string& val) { + this->operation = val; +} + +void OperationSamplingStrategy::__set_probabilisticSampling(const ProbabilisticSamplingStrategy& val) { + this->probabilisticSampling = val; +} +std::ostream& operator<<(std::ostream& out, const OperationSamplingStrategy& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t OperationSamplingStrategy::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_operation = false; + bool isset_probabilisticSampling = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->operation); + isset_operation = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->probabilisticSampling.read(iprot); + isset_probabilisticSampling = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_operation) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_probabilisticSampling) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t OperationSamplingStrategy::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("OperationSamplingStrategy"); + + xfer += oprot->writeFieldBegin("operation", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->operation); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("probabilisticSampling", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->probabilisticSampling.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(OperationSamplingStrategy &a, OperationSamplingStrategy &b) { + using ::std::swap; + swap(a.operation, b.operation); + swap(a.probabilisticSampling, b.probabilisticSampling); +} + +OperationSamplingStrategy::OperationSamplingStrategy(const OperationSamplingStrategy& other4) { + operation = other4.operation; + probabilisticSampling = other4.probabilisticSampling; +} +OperationSamplingStrategy& OperationSamplingStrategy::operator=(const OperationSamplingStrategy& other5) { + operation = other5.operation; + probabilisticSampling = other5.probabilisticSampling; + return *this; +} +void OperationSamplingStrategy::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "OperationSamplingStrategy("; + out << "operation=" << to_string(operation); + out << ", " << "probabilisticSampling=" << to_string(probabilisticSampling); + out << ")"; +} + + +PerOperationSamplingStrategies::~PerOperationSamplingStrategies() throw() { +} + + +void PerOperationSamplingStrategies::__set_defaultSamplingProbability(const double val) { + this->defaultSamplingProbability = val; +} + +void PerOperationSamplingStrategies::__set_defaultLowerBoundTracesPerSecond(const double val) { + this->defaultLowerBoundTracesPerSecond = val; +} + +void PerOperationSamplingStrategies::__set_perOperationStrategies(const std::vector<OperationSamplingStrategy> & val) { + this->perOperationStrategies = val; +} + +void PerOperationSamplingStrategies::__set_defaultUpperBoundTracesPerSecond(const double val) { + this->defaultUpperBoundTracesPerSecond = val; +__isset.defaultUpperBoundTracesPerSecond = true; +} +std::ostream& operator<<(std::ostream& out, const PerOperationSamplingStrategies& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t PerOperationSamplingStrategies::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_defaultSamplingProbability = false; + bool isset_defaultLowerBoundTracesPerSecond = false; + bool isset_perOperationStrategies = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->defaultSamplingProbability); + isset_defaultSamplingProbability = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->defaultLowerBoundTracesPerSecond); + isset_defaultLowerBoundTracesPerSecond = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->perOperationStrategies.clear(); + uint32_t _size6; + ::apache::thrift::protocol::TType _etype9; + xfer += iprot->readListBegin(_etype9, _size6); + this->perOperationStrategies.resize(_size6); + uint32_t _i10; + for (_i10 = 0; _i10 < _size6; ++_i10) + { + xfer += this->perOperationStrategies[_i10].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_perOperationStrategies = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->defaultUpperBoundTracesPerSecond); + this->__isset.defaultUpperBoundTracesPerSecond = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_defaultSamplingProbability) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_defaultLowerBoundTracesPerSecond) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_perOperationStrategies) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PerOperationSamplingStrategies::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PerOperationSamplingStrategies"); + + xfer += oprot->writeFieldBegin("defaultSamplingProbability", ::apache::thrift::protocol::T_DOUBLE, 1); + xfer += oprot->writeDouble(this->defaultSamplingProbability); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("defaultLowerBoundTracesPerSecond", ::apache::thrift::protocol::T_DOUBLE, 2); + xfer += oprot->writeDouble(this->defaultLowerBoundTracesPerSecond); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("perOperationStrategies", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->perOperationStrategies.size())); + std::vector<OperationSamplingStrategy> ::const_iterator _iter11; + for (_iter11 = this->perOperationStrategies.begin(); _iter11 != this->perOperationStrategies.end(); ++_iter11) + { + xfer += (*_iter11).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.defaultUpperBoundTracesPerSecond) { + xfer += oprot->writeFieldBegin("defaultUpperBoundTracesPerSecond", ::apache::thrift::protocol::T_DOUBLE, 4); + xfer += oprot->writeDouble(this->defaultUpperBoundTracesPerSecond); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PerOperationSamplingStrategies &a, PerOperationSamplingStrategies &b) { + using ::std::swap; + swap(a.defaultSamplingProbability, b.defaultSamplingProbability); + swap(a.defaultLowerBoundTracesPerSecond, b.defaultLowerBoundTracesPerSecond); + swap(a.perOperationStrategies, b.perOperationStrategies); + swap(a.defaultUpperBoundTracesPerSecond, b.defaultUpperBoundTracesPerSecond); + swap(a.__isset, b.__isset); +} + +PerOperationSamplingStrategies::PerOperationSamplingStrategies(const PerOperationSamplingStrategies& other12) { + defaultSamplingProbability = other12.defaultSamplingProbability; + defaultLowerBoundTracesPerSecond = other12.defaultLowerBoundTracesPerSecond; + perOperationStrategies = other12.perOperationStrategies; + defaultUpperBoundTracesPerSecond = other12.defaultUpperBoundTracesPerSecond; + __isset = other12.__isset; +} +PerOperationSamplingStrategies& PerOperationSamplingStrategies::operator=(const PerOperationSamplingStrategies& other13) { + defaultSamplingProbability = other13.defaultSamplingProbability; + defaultLowerBoundTracesPerSecond = other13.defaultLowerBoundTracesPerSecond; + perOperationStrategies = other13.perOperationStrategies; + defaultUpperBoundTracesPerSecond = other13.defaultUpperBoundTracesPerSecond; + __isset = other13.__isset; + return *this; +} +void PerOperationSamplingStrategies::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PerOperationSamplingStrategies("; + out << "defaultSamplingProbability=" << to_string(defaultSamplingProbability); + out << ", " << "defaultLowerBoundTracesPerSecond=" << to_string(defaultLowerBoundTracesPerSecond); + out << ", " << "perOperationStrategies=" << to_string(perOperationStrategies); + out << ", " << "defaultUpperBoundTracesPerSecond="; (__isset.defaultUpperBoundTracesPerSecond ? (out << to_string(defaultUpperBoundTracesPerSecond)) : (out << "<null>")); + out << ")"; +} + + +SamplingStrategyResponse::~SamplingStrategyResponse() throw() { +} + + +void SamplingStrategyResponse::__set_strategyType(const SamplingStrategyType::type val) { + this->strategyType = val; +} + +void SamplingStrategyResponse::__set_probabilisticSampling(const ProbabilisticSamplingStrategy& val) { + this->probabilisticSampling = val; +__isset.probabilisticSampling = true; +} + +void SamplingStrategyResponse::__set_rateLimitingSampling(const RateLimitingSamplingStrategy& val) { + this->rateLimitingSampling = val; +__isset.rateLimitingSampling = true; +} + +void SamplingStrategyResponse::__set_operationSampling(const PerOperationSamplingStrategies& val) { + this->operationSampling = val; +__isset.operationSampling = true; +} +std::ostream& operator<<(std::ostream& out, const SamplingStrategyResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t SamplingStrategyResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_strategyType = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast14; + xfer += iprot->readI32(ecast14); + this->strategyType = (SamplingStrategyType::type)ecast14; + isset_strategyType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->probabilisticSampling.read(iprot); + this->__isset.probabilisticSampling = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rateLimitingSampling.read(iprot); + this->__isset.rateLimitingSampling = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->operationSampling.read(iprot); + this->__isset.operationSampling = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_strategyType) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SamplingStrategyResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SamplingStrategyResponse"); + + xfer += oprot->writeFieldBegin("strategyType", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((int32_t)this->strategyType); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.probabilisticSampling) { + xfer += oprot->writeFieldBegin("probabilisticSampling", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->probabilisticSampling.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.rateLimitingSampling) { + xfer += oprot->writeFieldBegin("rateLimitingSampling", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->rateLimitingSampling.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.operationSampling) { + xfer += oprot->writeFieldBegin("operationSampling", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->operationSampling.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SamplingStrategyResponse &a, SamplingStrategyResponse &b) { + using ::std::swap; + swap(a.strategyType, b.strategyType); + swap(a.probabilisticSampling, b.probabilisticSampling); + swap(a.rateLimitingSampling, b.rateLimitingSampling); + swap(a.operationSampling, b.operationSampling); + swap(a.__isset, b.__isset); +} + +SamplingStrategyResponse::SamplingStrategyResponse(const SamplingStrategyResponse& other15) { + strategyType = other15.strategyType; + probabilisticSampling = other15.probabilisticSampling; + rateLimitingSampling = other15.rateLimitingSampling; + operationSampling = other15.operationSampling; + __isset = other15.__isset; +} +SamplingStrategyResponse& SamplingStrategyResponse::operator=(const SamplingStrategyResponse& other16) { + strategyType = other16.strategyType; + probabilisticSampling = other16.probabilisticSampling; + rateLimitingSampling = other16.rateLimitingSampling; + operationSampling = other16.operationSampling; + __isset = other16.__isset; + return *this; +} +void SamplingStrategyResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SamplingStrategyResponse("; + out << "strategyType=" << to_string(strategyType); + out << ", " << "probabilisticSampling="; (__isset.probabilisticSampling ? (out << to_string(probabilisticSampling)) : (out << "<null>")); + out << ", " << "rateLimitingSampling="; (__isset.rateLimitingSampling ? (out << to_string(rateLimitingSampling)) : (out << "<null>")); + out << ", " << "operationSampling="; (__isset.operationSampling ? (out << to_string(operationSampling)) : (out << "<null>")); + out << ")"; +} + +}}} // namespace diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_types.h new file mode 100644 index 000000000..49c63d6f7 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/sampling_types.h @@ -0,0 +1,283 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef sampling_TYPES_H +#define sampling_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/TBase.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + + + + +namespace jaegertracing { namespace sampling_manager { namespace thrift { + +struct SamplingStrategyType { + enum type { + PROBABILISTIC = 0, + RATE_LIMITING = 1 + }; +}; + +extern const std::map<int, const char*> _SamplingStrategyType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const SamplingStrategyType::type& val); + +class ProbabilisticSamplingStrategy; + +class RateLimitingSamplingStrategy; + +class OperationSamplingStrategy; + +class PerOperationSamplingStrategies; + +class SamplingStrategyResponse; + + +class ProbabilisticSamplingStrategy : public virtual ::apache::thrift::TBase { + public: + + ProbabilisticSamplingStrategy(const ProbabilisticSamplingStrategy&); + ProbabilisticSamplingStrategy& operator=(const ProbabilisticSamplingStrategy&); + ProbabilisticSamplingStrategy() : samplingRate(0) { + } + + virtual ~ProbabilisticSamplingStrategy() throw(); + double samplingRate; + + void __set_samplingRate(const double val); + + bool operator == (const ProbabilisticSamplingStrategy & rhs) const + { + if (!(samplingRate == rhs.samplingRate)) + return false; + return true; + } + bool operator != (const ProbabilisticSamplingStrategy &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ProbabilisticSamplingStrategy & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ProbabilisticSamplingStrategy &a, ProbabilisticSamplingStrategy &b); + +std::ostream& operator<<(std::ostream& out, const ProbabilisticSamplingStrategy& obj); + + +class RateLimitingSamplingStrategy : public virtual ::apache::thrift::TBase { + public: + + RateLimitingSamplingStrategy(const RateLimitingSamplingStrategy&); + RateLimitingSamplingStrategy& operator=(const RateLimitingSamplingStrategy&); + RateLimitingSamplingStrategy() : maxTracesPerSecond(0) { + } + + virtual ~RateLimitingSamplingStrategy() throw(); + int16_t maxTracesPerSecond; + + void __set_maxTracesPerSecond(const int16_t val); + + bool operator == (const RateLimitingSamplingStrategy & rhs) const + { + if (!(maxTracesPerSecond == rhs.maxTracesPerSecond)) + return false; + return true; + } + bool operator != (const RateLimitingSamplingStrategy &rhs) const { + return !(*this == rhs); + } + + bool operator < (const RateLimitingSamplingStrategy & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(RateLimitingSamplingStrategy &a, RateLimitingSamplingStrategy &b); + +std::ostream& operator<<(std::ostream& out, const RateLimitingSamplingStrategy& obj); + + +class OperationSamplingStrategy : public virtual ::apache::thrift::TBase { + public: + + OperationSamplingStrategy(const OperationSamplingStrategy&); + OperationSamplingStrategy& operator=(const OperationSamplingStrategy&); + OperationSamplingStrategy() : operation() { + } + + virtual ~OperationSamplingStrategy() throw(); + std::string operation; + ProbabilisticSamplingStrategy probabilisticSampling; + + void __set_operation(const std::string& val); + + void __set_probabilisticSampling(const ProbabilisticSamplingStrategy& val); + + bool operator == (const OperationSamplingStrategy & rhs) const + { + if (!(operation == rhs.operation)) + return false; + if (!(probabilisticSampling == rhs.probabilisticSampling)) + return false; + return true; + } + bool operator != (const OperationSamplingStrategy &rhs) const { + return !(*this == rhs); + } + + bool operator < (const OperationSamplingStrategy & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(OperationSamplingStrategy &a, OperationSamplingStrategy &b); + +std::ostream& operator<<(std::ostream& out, const OperationSamplingStrategy& obj); + +typedef struct _PerOperationSamplingStrategies__isset { + _PerOperationSamplingStrategies__isset() : defaultUpperBoundTracesPerSecond(false) {} + bool defaultUpperBoundTracesPerSecond :1; +} _PerOperationSamplingStrategies__isset; + +class PerOperationSamplingStrategies : public virtual ::apache::thrift::TBase { + public: + + PerOperationSamplingStrategies(const PerOperationSamplingStrategies&); + PerOperationSamplingStrategies& operator=(const PerOperationSamplingStrategies&); + PerOperationSamplingStrategies() : defaultSamplingProbability(0), defaultLowerBoundTracesPerSecond(0), defaultUpperBoundTracesPerSecond(0) { + } + + virtual ~PerOperationSamplingStrategies() throw(); + double defaultSamplingProbability; + double defaultLowerBoundTracesPerSecond; + std::vector<OperationSamplingStrategy> perOperationStrategies; + double defaultUpperBoundTracesPerSecond; + + _PerOperationSamplingStrategies__isset __isset; + + void __set_defaultSamplingProbability(const double val); + + void __set_defaultLowerBoundTracesPerSecond(const double val); + + void __set_perOperationStrategies(const std::vector<OperationSamplingStrategy> & val); + + void __set_defaultUpperBoundTracesPerSecond(const double val); + + bool operator == (const PerOperationSamplingStrategies & rhs) const + { + if (!(defaultSamplingProbability == rhs.defaultSamplingProbability)) + return false; + if (!(defaultLowerBoundTracesPerSecond == rhs.defaultLowerBoundTracesPerSecond)) + return false; + if (!(perOperationStrategies == rhs.perOperationStrategies)) + return false; + if (__isset.defaultUpperBoundTracesPerSecond != rhs.__isset.defaultUpperBoundTracesPerSecond) + return false; + else if (__isset.defaultUpperBoundTracesPerSecond && !(defaultUpperBoundTracesPerSecond == rhs.defaultUpperBoundTracesPerSecond)) + return false; + return true; + } + bool operator != (const PerOperationSamplingStrategies &rhs) const { + return !(*this == rhs); + } + + bool operator < (const PerOperationSamplingStrategies & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(PerOperationSamplingStrategies &a, PerOperationSamplingStrategies &b); + +std::ostream& operator<<(std::ostream& out, const PerOperationSamplingStrategies& obj); + +typedef struct _SamplingStrategyResponse__isset { + _SamplingStrategyResponse__isset() : probabilisticSampling(false), rateLimitingSampling(false), operationSampling(false) {} + bool probabilisticSampling :1; + bool rateLimitingSampling :1; + bool operationSampling :1; +} _SamplingStrategyResponse__isset; + +class SamplingStrategyResponse : public virtual ::apache::thrift::TBase { + public: + + SamplingStrategyResponse(const SamplingStrategyResponse&); + SamplingStrategyResponse& operator=(const SamplingStrategyResponse&); + SamplingStrategyResponse() : strategyType((SamplingStrategyType::type)0) { + } + + virtual ~SamplingStrategyResponse() throw(); + SamplingStrategyType::type strategyType; + ProbabilisticSamplingStrategy probabilisticSampling; + RateLimitingSamplingStrategy rateLimitingSampling; + PerOperationSamplingStrategies operationSampling; + + _SamplingStrategyResponse__isset __isset; + + void __set_strategyType(const SamplingStrategyType::type val); + + void __set_probabilisticSampling(const ProbabilisticSamplingStrategy& val); + + void __set_rateLimitingSampling(const RateLimitingSamplingStrategy& val); + + void __set_operationSampling(const PerOperationSamplingStrategies& val); + + bool operator == (const SamplingStrategyResponse & rhs) const + { + if (!(strategyType == rhs.strategyType)) + return false; + if (__isset.probabilisticSampling != rhs.__isset.probabilisticSampling) + return false; + else if (__isset.probabilisticSampling && !(probabilisticSampling == rhs.probabilisticSampling)) + return false; + if (__isset.rateLimitingSampling != rhs.__isset.rateLimitingSampling) + return false; + else if (__isset.rateLimitingSampling && !(rateLimitingSampling == rhs.rateLimitingSampling)) + return false; + if (__isset.operationSampling != rhs.__isset.operationSampling) + return false; + else if (__isset.operationSampling && !(operationSampling == rhs.operationSampling)) + return false; + return true; + } + bool operator != (const SamplingStrategyResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SamplingStrategyResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SamplingStrategyResponse &a, SamplingStrategyResponse &b); + +std::ostream& operator<<(std::ostream& out, const SamplingStrategyResponse& obj); + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_constants.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_constants.cpp new file mode 100644 index 000000000..8738dd2c8 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_constants.cpp @@ -0,0 +1,17 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "tracetest_constants.h" + +namespace jaegertracing { namespace crossdock { namespace thrift { + +const tracetestConstants g_tracetest_constants; + +tracetestConstants::tracetestConstants() { +} + +}}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_constants.h new file mode 100644 index 000000000..96bf29048 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_constants.h @@ -0,0 +1,24 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef tracetest_CONSTANTS_H +#define tracetest_CONSTANTS_H + +#include "tracetest_types.h" + +namespace jaegertracing { namespace crossdock { namespace thrift { + +class tracetestConstants { + public: + tracetestConstants(); + +}; + +extern const tracetestConstants g_tracetest_constants; + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_types.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_types.cpp new file mode 100644 index 000000000..ceb7a204d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_types.cpp @@ -0,0 +1,804 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "tracetest_types.h" + +#include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> + +namespace jaegertracing { namespace crossdock { namespace thrift { + +int _kTransportValues[] = { + Transport::HTTP, + Transport::TCHANNEL, + Transport::DUMMY +}; +const char* _kTransportNames[] = { + "HTTP", + "TCHANNEL", + "DUMMY" +}; +const std::map<int, const char*> _Transport_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kTransportValues, _kTransportNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +std::ostream& operator<<(std::ostream& out, const Transport::type& val) { + std::map<int, const char*>::const_iterator it = _Transport_VALUES_TO_NAMES.find(val); + if (it != _Transport_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast<int>(val); + } + return out; +} + + +Downstream::~Downstream() throw() { +} + + +void Downstream::__set_serviceName(const std::string& val) { + this->serviceName = val; +} + +void Downstream::__set_serverRole(const std::string& val) { + this->serverRole = val; +} + +void Downstream::__set_host(const std::string& val) { + this->host = val; +} + +void Downstream::__set_port(const std::string& val) { + this->port = val; +} + +void Downstream::__set_transport(const Transport::type val) { + this->transport = val; +} + +void Downstream::__set_downstream(const std::shared_ptr<Downstream>& val) { + this->downstream = val; +__isset.downstream = true; +} +std::ostream& operator<<(std::ostream& out, const Downstream& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Downstream::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_serviceName = false; + bool isset_serverRole = false; + bool isset_host = false; + bool isset_port = false; + bool isset_transport = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serviceName); + isset_serviceName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serverRole); + isset_serverRole = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->host); + isset_host = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->port); + isset_port = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast0; + xfer += iprot->readI32(ecast0); + this->transport = (Transport::type)ecast0; + isset_transport = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->downstream->read(iprot); + this->__isset.downstream = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_serviceName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_serverRole) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_host) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_port) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_transport) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Downstream::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Downstream"); + + xfer += oprot->writeFieldBegin("serviceName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->serviceName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("serverRole", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->serverRole); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("host", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->host); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("port", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->port); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("transport", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32((int32_t)this->transport); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.downstream) { + xfer += oprot->writeFieldBegin("downstream", ::apache::thrift::protocol::T_STRUCT, 6); + xfer += this->downstream->write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Downstream &a, Downstream &b) { + using ::std::swap; + swap(a.serviceName, b.serviceName); + swap(a.serverRole, b.serverRole); + swap(a.host, b.host); + swap(a.port, b.port); + swap(a.transport, b.transport); + swap(a.downstream, b.downstream); + swap(a.__isset, b.__isset); +} + +Downstream::Downstream(const Downstream& other1) { + serviceName = other1.serviceName; + serverRole = other1.serverRole; + host = other1.host; + port = other1.port; + transport = other1.transport; + downstream = other1.downstream; + __isset = other1.__isset; +} +Downstream& Downstream::operator=(const Downstream& other2) { + serviceName = other2.serviceName; + serverRole = other2.serverRole; + host = other2.host; + port = other2.port; + transport = other2.transport; + downstream = other2.downstream; + __isset = other2.__isset; + return *this; +} +void Downstream::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Downstream("; + out << "serviceName=" << to_string(serviceName); + out << ", " << "serverRole=" << to_string(serverRole); + out << ", " << "host=" << to_string(host); + out << ", " << "port=" << to_string(port); + out << ", " << "transport=" << to_string(transport); + out << ", " << "downstream="; (__isset.downstream ? (out << to_string(downstream)) : (out << "<null>")); + out << ")"; +} + + +StartTraceRequest::~StartTraceRequest() throw() { +} + + +void StartTraceRequest::__set_serverRole(const std::string& val) { + this->serverRole = val; +} + +void StartTraceRequest::__set_sampled(const bool val) { + this->sampled = val; +} + +void StartTraceRequest::__set_baggage(const std::string& val) { + this->baggage = val; +} + +void StartTraceRequest::__set_downstream(const Downstream& val) { + this->downstream = val; +} +std::ostream& operator<<(std::ostream& out, const StartTraceRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t StartTraceRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_serverRole = false; + bool isset_sampled = false; + bool isset_baggage = false; + bool isset_downstream = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serverRole); + isset_serverRole = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->sampled); + isset_sampled = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->baggage); + isset_baggage = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->downstream.read(iprot); + isset_downstream = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_serverRole) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_sampled) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_baggage) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_downstream) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t StartTraceRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("StartTraceRequest"); + + xfer += oprot->writeFieldBegin("serverRole", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->serverRole); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("sampled", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->sampled); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("baggage", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->baggage); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("downstream", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->downstream.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(StartTraceRequest &a, StartTraceRequest &b) { + using ::std::swap; + swap(a.serverRole, b.serverRole); + swap(a.sampled, b.sampled); + swap(a.baggage, b.baggage); + swap(a.downstream, b.downstream); +} + +StartTraceRequest::StartTraceRequest(const StartTraceRequest& other3) { + serverRole = other3.serverRole; + sampled = other3.sampled; + baggage = other3.baggage; + downstream = other3.downstream; +} +StartTraceRequest& StartTraceRequest::operator=(const StartTraceRequest& other4) { + serverRole = other4.serverRole; + sampled = other4.sampled; + baggage = other4.baggage; + downstream = other4.downstream; + return *this; +} +void StartTraceRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "StartTraceRequest("; + out << "serverRole=" << to_string(serverRole); + out << ", " << "sampled=" << to_string(sampled); + out << ", " << "baggage=" << to_string(baggage); + out << ", " << "downstream=" << to_string(downstream); + out << ")"; +} + + +JoinTraceRequest::~JoinTraceRequest() throw() { +} + + +void JoinTraceRequest::__set_serverRole(const std::string& val) { + this->serverRole = val; +} + +void JoinTraceRequest::__set_downstream(const Downstream& val) { + this->downstream = val; +__isset.downstream = true; +} +std::ostream& operator<<(std::ostream& out, const JoinTraceRequest& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t JoinTraceRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_serverRole = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serverRole); + isset_serverRole = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->downstream.read(iprot); + this->__isset.downstream = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_serverRole) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t JoinTraceRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("JoinTraceRequest"); + + xfer += oprot->writeFieldBegin("serverRole", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->serverRole); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.downstream) { + xfer += oprot->writeFieldBegin("downstream", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->downstream.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(JoinTraceRequest &a, JoinTraceRequest &b) { + using ::std::swap; + swap(a.serverRole, b.serverRole); + swap(a.downstream, b.downstream); + swap(a.__isset, b.__isset); +} + +JoinTraceRequest::JoinTraceRequest(const JoinTraceRequest& other5) { + serverRole = other5.serverRole; + downstream = other5.downstream; + __isset = other5.__isset; +} +JoinTraceRequest& JoinTraceRequest::operator=(const JoinTraceRequest& other6) { + serverRole = other6.serverRole; + downstream = other6.downstream; + __isset = other6.__isset; + return *this; +} +void JoinTraceRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "JoinTraceRequest("; + out << "serverRole=" << to_string(serverRole); + out << ", " << "downstream="; (__isset.downstream ? (out << to_string(downstream)) : (out << "<null>")); + out << ")"; +} + + +ObservedSpan::~ObservedSpan() throw() { +} + + +void ObservedSpan::__set_traceId(const std::string& val) { + this->traceId = val; +} + +void ObservedSpan::__set_sampled(const bool val) { + this->sampled = val; +} + +void ObservedSpan::__set_baggage(const std::string& val) { + this->baggage = val; +} +std::ostream& operator<<(std::ostream& out, const ObservedSpan& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t ObservedSpan::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_traceId = false; + bool isset_sampled = false; + bool isset_baggage = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->traceId); + isset_traceId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->sampled); + isset_sampled = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->baggage); + isset_baggage = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_traceId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_sampled) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_baggage) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ObservedSpan::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ObservedSpan"); + + xfer += oprot->writeFieldBegin("traceId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->traceId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("sampled", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->sampled); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("baggage", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->baggage); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ObservedSpan &a, ObservedSpan &b) { + using ::std::swap; + swap(a.traceId, b.traceId); + swap(a.sampled, b.sampled); + swap(a.baggage, b.baggage); +} + +ObservedSpan::ObservedSpan(const ObservedSpan& other7) { + traceId = other7.traceId; + sampled = other7.sampled; + baggage = other7.baggage; +} +ObservedSpan& ObservedSpan::operator=(const ObservedSpan& other8) { + traceId = other8.traceId; + sampled = other8.sampled; + baggage = other8.baggage; + return *this; +} +void ObservedSpan::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ObservedSpan("; + out << "traceId=" << to_string(traceId); + out << ", " << "sampled=" << to_string(sampled); + out << ", " << "baggage=" << to_string(baggage); + out << ")"; +} + + +TraceResponse::~TraceResponse() throw() { +} + + +void TraceResponse::__set_span(const ObservedSpan& val) { + this->span = val; +__isset.span = true; +} + +void TraceResponse::__set_downstream(const std::shared_ptr<TraceResponse>& val) { + this->downstream = val; +__isset.downstream = true; +} + +void TraceResponse::__set_notImplementedError(const std::string& val) { + this->notImplementedError = val; +} +std::ostream& operator<<(std::ostream& out, const TraceResponse& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TraceResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_notImplementedError = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->span.read(iprot); + this->__isset.span = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->downstream->read(iprot); + this->__isset.downstream = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->notImplementedError); + isset_notImplementedError = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_notImplementedError) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TraceResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TraceResponse"); + + if (this->__isset.span) { + xfer += oprot->writeFieldBegin("span", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->span.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.downstream) { + xfer += oprot->writeFieldBegin("downstream", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->downstream->write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("notImplementedError", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->notImplementedError); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TraceResponse &a, TraceResponse &b) { + using ::std::swap; + swap(a.span, b.span); + swap(a.downstream, b.downstream); + swap(a.notImplementedError, b.notImplementedError); + swap(a.__isset, b.__isset); +} + +TraceResponse::TraceResponse(const TraceResponse& other9) { + span = other9.span; + downstream = other9.downstream; + notImplementedError = other9.notImplementedError; + __isset = other9.__isset; +} +TraceResponse& TraceResponse::operator=(const TraceResponse& other10) { + span = other10.span; + downstream = other10.downstream; + notImplementedError = other10.notImplementedError; + __isset = other10.__isset; + return *this; +} +void TraceResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TraceResponse("; + out << "span="; (__isset.span ? (out << to_string(span)) : (out << "<null>")); + out << ", " << "downstream="; (__isset.downstream ? (out << to_string(downstream)) : (out << "<null>")); + out << ", " << "notImplementedError=" << to_string(notImplementedError); + out << ")"; +} + +}}} // namespace diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_types.h new file mode 100644 index 000000000..90c0b9666 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/tracetest_types.h @@ -0,0 +1,316 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef tracetest_TYPES_H +#define tracetest_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/TBase.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + +namespace jaegertracing { namespace crossdock { namespace thrift { + +struct Transport { + enum type { + HTTP = 0, + TCHANNEL = 1, + DUMMY = 2 + }; +}; + +extern const std::map<int, const char*> _Transport_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const Transport::type& val); + +class Downstream; + +class StartTraceRequest; + +class JoinTraceRequest; + +class ObservedSpan; + +class TraceResponse; + +typedef struct _Downstream__isset { + _Downstream__isset() : downstream(false) {} + bool downstream :1; +} _Downstream__isset; + +class Downstream : public virtual ::apache::thrift::TBase { + public: + + Downstream(const Downstream&); + Downstream& operator=(const Downstream&); + Downstream() : serviceName(), serverRole(), host(), port(), transport((Transport::type)0) { + } + + virtual ~Downstream() throw(); + std::string serviceName; + std::string serverRole; + std::string host; + std::string port; + Transport::type transport; + std::shared_ptr<Downstream> downstream; + + _Downstream__isset __isset; + + void __set_serviceName(const std::string& val); + + void __set_serverRole(const std::string& val); + + void __set_host(const std::string& val); + + void __set_port(const std::string& val); + + void __set_transport(const Transport::type val); + + void __set_downstream(const std::shared_ptr<Downstream>& val); + + bool operator == (const Downstream & rhs) const + { + if (!(serviceName == rhs.serviceName)) + return false; + if (!(serverRole == rhs.serverRole)) + return false; + if (!(host == rhs.host)) + return false; + if (!(port == rhs.port)) + return false; + if (!(transport == rhs.transport)) + return false; + if (__isset.downstream != rhs.__isset.downstream) + return false; + else if (__isset.downstream && !(*downstream == *rhs.downstream)) + return false; + return true; + } + bool operator != (const Downstream &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Downstream & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Downstream &a, Downstream &b); + +std::ostream& operator<<(std::ostream& out, const Downstream& obj); + + +class StartTraceRequest : public virtual ::apache::thrift::TBase { + public: + + StartTraceRequest(const StartTraceRequest&); + StartTraceRequest& operator=(const StartTraceRequest&); + StartTraceRequest() : serverRole(), sampled(0), baggage() { + } + + virtual ~StartTraceRequest() throw(); + std::string serverRole; + bool sampled; + std::string baggage; + Downstream downstream; + + void __set_serverRole(const std::string& val); + + void __set_sampled(const bool val); + + void __set_baggage(const std::string& val); + + void __set_downstream(const Downstream& val); + + bool operator == (const StartTraceRequest & rhs) const + { + if (!(serverRole == rhs.serverRole)) + return false; + if (!(sampled == rhs.sampled)) + return false; + if (!(baggage == rhs.baggage)) + return false; + if (!(downstream == rhs.downstream)) + return false; + return true; + } + bool operator != (const StartTraceRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const StartTraceRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(StartTraceRequest &a, StartTraceRequest &b); + +std::ostream& operator<<(std::ostream& out, const StartTraceRequest& obj); + +typedef struct _JoinTraceRequest__isset { + _JoinTraceRequest__isset() : downstream(false) {} + bool downstream :1; +} _JoinTraceRequest__isset; + +class JoinTraceRequest : public virtual ::apache::thrift::TBase { + public: + + JoinTraceRequest(const JoinTraceRequest&); + JoinTraceRequest& operator=(const JoinTraceRequest&); + JoinTraceRequest() : serverRole() { + } + + virtual ~JoinTraceRequest() throw(); + std::string serverRole; + Downstream downstream; + + _JoinTraceRequest__isset __isset; + + void __set_serverRole(const std::string& val); + + void __set_downstream(const Downstream& val); + + bool operator == (const JoinTraceRequest & rhs) const + { + if (!(serverRole == rhs.serverRole)) + return false; + if (__isset.downstream != rhs.__isset.downstream) + return false; + else if (__isset.downstream && !(downstream == rhs.downstream)) + return false; + return true; + } + bool operator != (const JoinTraceRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const JoinTraceRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(JoinTraceRequest &a, JoinTraceRequest &b); + +std::ostream& operator<<(std::ostream& out, const JoinTraceRequest& obj); + + +class ObservedSpan : public virtual ::apache::thrift::TBase { + public: + + ObservedSpan(const ObservedSpan&); + ObservedSpan& operator=(const ObservedSpan&); + ObservedSpan() : traceId(), sampled(0), baggage() { + } + + virtual ~ObservedSpan() throw(); + std::string traceId; + bool sampled; + std::string baggage; + + void __set_traceId(const std::string& val); + + void __set_sampled(const bool val); + + void __set_baggage(const std::string& val); + + bool operator == (const ObservedSpan & rhs) const + { + if (!(traceId == rhs.traceId)) + return false; + if (!(sampled == rhs.sampled)) + return false; + if (!(baggage == rhs.baggage)) + return false; + return true; + } + bool operator != (const ObservedSpan &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ObservedSpan & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(ObservedSpan &a, ObservedSpan &b); + +std::ostream& operator<<(std::ostream& out, const ObservedSpan& obj); + +typedef struct _TraceResponse__isset { + _TraceResponse__isset() : span(false), downstream(false) {} + bool span :1; + bool downstream :1; +} _TraceResponse__isset; + +class TraceResponse : public virtual ::apache::thrift::TBase { + public: + + TraceResponse(const TraceResponse&); + TraceResponse& operator=(const TraceResponse&); + TraceResponse() : notImplementedError() { + } + + virtual ~TraceResponse() throw(); + ObservedSpan span; + std::shared_ptr<TraceResponse> downstream; + std::string notImplementedError; + + _TraceResponse__isset __isset; + + void __set_span(const ObservedSpan& val); + + void __set_downstream(const std::shared_ptr<TraceResponse>& val); + + void __set_notImplementedError(const std::string& val); + + bool operator == (const TraceResponse & rhs) const + { + if (__isset.span != rhs.__isset.span) + return false; + else if (__isset.span && !(span == rhs.span)) + return false; + if (__isset.downstream != rhs.__isset.downstream) + return false; + else if (__isset.downstream && !(*downstream == *rhs.downstream)) + return false; + if (!(notImplementedError == rhs.notImplementedError)) + return false; + return true; + } + bool operator != (const TraceResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TraceResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TraceResponse &a, TraceResponse &b); + +std::ostream& operator<<(std::ostream& out, const TraceResponse& obj); + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_constants.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_constants.cpp new file mode 100644 index 000000000..3b463710a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_constants.cpp @@ -0,0 +1,49 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "zipkincore_constants.h" + +namespace twitter { namespace zipkin { namespace thrift { + +const zipkincoreConstants g_zipkincore_constants; + +zipkincoreConstants::zipkincoreConstants() { + CLIENT_SEND = "cs"; + + CLIENT_RECV = "cr"; + + SERVER_SEND = "ss"; + + SERVER_RECV = "sr"; + + MESSAGE_SEND = "ms"; + + MESSAGE_RECV = "mr"; + + WIRE_SEND = "ws"; + + WIRE_RECV = "wr"; + + CLIENT_SEND_FRAGMENT = "csf"; + + CLIENT_RECV_FRAGMENT = "crf"; + + SERVER_SEND_FRAGMENT = "ssf"; + + SERVER_RECV_FRAGMENT = "srf"; + + LOCAL_COMPONENT = "lc"; + + CLIENT_ADDR = "ca"; + + SERVER_ADDR = "sa"; + + MESSAGE_ADDR = "ma"; + +} + +}}} // namespace + diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_constants.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_constants.h new file mode 100644 index 000000000..b759e0695 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_constants.h @@ -0,0 +1,40 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef zipkincore_CONSTANTS_H +#define zipkincore_CONSTANTS_H + +#include "zipkincore_types.h" + +namespace twitter { namespace zipkin { namespace thrift { + +class zipkincoreConstants { + public: + zipkincoreConstants(); + + std::string CLIENT_SEND; + std::string CLIENT_RECV; + std::string SERVER_SEND; + std::string SERVER_RECV; + std::string MESSAGE_SEND; + std::string MESSAGE_RECV; + std::string WIRE_SEND; + std::string WIRE_RECV; + std::string CLIENT_SEND_FRAGMENT; + std::string CLIENT_RECV_FRAGMENT; + std::string SERVER_SEND_FRAGMENT; + std::string SERVER_RECV_FRAGMENT; + std::string LOCAL_COMPONENT; + std::string CLIENT_ADDR; + std::string SERVER_ADDR; + std::string MESSAGE_ADDR; +}; + +extern const zipkincoreConstants g_zipkincore_constants; + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_types.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_types.cpp new file mode 100644 index 000000000..de44dbbbc --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_types.cpp @@ -0,0 +1,904 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "zipkincore_types.h" + +#include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> + +namespace twitter { namespace zipkin { namespace thrift { + +int _kAnnotationTypeValues[] = { + AnnotationType::BOOL, + AnnotationType::BYTES, + AnnotationType::I16, + AnnotationType::I32, + AnnotationType::I64, + AnnotationType::DOUBLE, + AnnotationType::STRING +}; +const char* _kAnnotationTypeNames[] = { + "BOOL", + "BYTES", + "I16", + "I32", + "I64", + "DOUBLE", + "STRING" +}; +const std::map<int, const char*> _AnnotationType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(7, _kAnnotationTypeValues, _kAnnotationTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +std::ostream& operator<<(std::ostream& out, const AnnotationType::type& val) { + std::map<int, const char*>::const_iterator it = _AnnotationType_VALUES_TO_NAMES.find(val); + if (it != _AnnotationType_VALUES_TO_NAMES.end()) { + out << it->second; + } else { + out << static_cast<int>(val); + } + return out; +} + + +Endpoint::~Endpoint() throw() { +} + + +void Endpoint::__set_ipv4(const int32_t val) { + this->ipv4 = val; +} + +void Endpoint::__set_port(const int16_t val) { + this->port = val; +} + +void Endpoint::__set_service_name(const std::string& val) { + this->service_name = val; +} + +void Endpoint::__set_ipv6(const std::string& val) { + this->ipv6 = val; +__isset.ipv6 = true; +} +std::ostream& operator<<(std::ostream& out, const Endpoint& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Endpoint::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->ipv4); + this->__isset.ipv4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->port); + this->__isset.port = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->service_name); + this->__isset.service_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->ipv6); + this->__isset.ipv6 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Endpoint::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Endpoint"); + + xfer += oprot->writeFieldBegin("ipv4", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->ipv4); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("port", ::apache::thrift::protocol::T_I16, 2); + xfer += oprot->writeI16(this->port); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("service_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->service_name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.ipv6) { + xfer += oprot->writeFieldBegin("ipv6", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeBinary(this->ipv6); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Endpoint &a, Endpoint &b) { + using ::std::swap; + swap(a.ipv4, b.ipv4); + swap(a.port, b.port); + swap(a.service_name, b.service_name); + swap(a.ipv6, b.ipv6); + swap(a.__isset, b.__isset); +} + +Endpoint::Endpoint(const Endpoint& other0) { + ipv4 = other0.ipv4; + port = other0.port; + service_name = other0.service_name; + ipv6 = other0.ipv6; + __isset = other0.__isset; +} +Endpoint& Endpoint::operator=(const Endpoint& other1) { + ipv4 = other1.ipv4; + port = other1.port; + service_name = other1.service_name; + ipv6 = other1.ipv6; + __isset = other1.__isset; + return *this; +} +void Endpoint::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Endpoint("; + out << "ipv4=" << to_string(ipv4); + out << ", " << "port=" << to_string(port); + out << ", " << "service_name=" << to_string(service_name); + out << ", " << "ipv6="; (__isset.ipv6 ? (out << to_string(ipv6)) : (out << "<null>")); + out << ")"; +} + + +Annotation::~Annotation() throw() { +} + + +void Annotation::__set_timestamp(const int64_t val) { + this->timestamp = val; +} + +void Annotation::__set_value(const std::string& val) { + this->value = val; +} + +void Annotation::__set_host(const Endpoint& val) { + this->host = val; +__isset.host = true; +} +std::ostream& operator<<(std::ostream& out, const Annotation& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Annotation::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->timestamp); + this->__isset.timestamp = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->value); + this->__isset.value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->host.read(iprot); + this->__isset.host = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Annotation::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Annotation"); + + xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->timestamp); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->value); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.host) { + xfer += oprot->writeFieldBegin("host", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->host.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Annotation &a, Annotation &b) { + using ::std::swap; + swap(a.timestamp, b.timestamp); + swap(a.value, b.value); + swap(a.host, b.host); + swap(a.__isset, b.__isset); +} + +Annotation::Annotation(const Annotation& other2) { + timestamp = other2.timestamp; + value = other2.value; + host = other2.host; + __isset = other2.__isset; +} +Annotation& Annotation::operator=(const Annotation& other3) { + timestamp = other3.timestamp; + value = other3.value; + host = other3.host; + __isset = other3.__isset; + return *this; +} +void Annotation::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Annotation("; + out << "timestamp=" << to_string(timestamp); + out << ", " << "value=" << to_string(value); + out << ", " << "host="; (__isset.host ? (out << to_string(host)) : (out << "<null>")); + out << ")"; +} + + +BinaryAnnotation::~BinaryAnnotation() throw() { +} + + +void BinaryAnnotation::__set_key(const std::string& val) { + this->key = val; +} + +void BinaryAnnotation::__set_value(const std::string& val) { + this->value = val; +} + +void BinaryAnnotation::__set_annotation_type(const AnnotationType::type val) { + this->annotation_type = val; +} + +void BinaryAnnotation::__set_host(const Endpoint& val) { + this->host = val; +__isset.host = true; +} +std::ostream& operator<<(std::ostream& out, const BinaryAnnotation& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t BinaryAnnotation::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->value); + this->__isset.value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast4; + xfer += iprot->readI32(ecast4); + this->annotation_type = (AnnotationType::type)ecast4; + this->__isset.annotation_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->host.read(iprot); + this->__isset.host = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t BinaryAnnotation::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("BinaryAnnotation"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeBinary(this->value); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("annotation_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)this->annotation_type); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.host) { + xfer += oprot->writeFieldBegin("host", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->host.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(BinaryAnnotation &a, BinaryAnnotation &b) { + using ::std::swap; + swap(a.key, b.key); + swap(a.value, b.value); + swap(a.annotation_type, b.annotation_type); + swap(a.host, b.host); + swap(a.__isset, b.__isset); +} + +BinaryAnnotation::BinaryAnnotation(const BinaryAnnotation& other5) { + key = other5.key; + value = other5.value; + annotation_type = other5.annotation_type; + host = other5.host; + __isset = other5.__isset; +} +BinaryAnnotation& BinaryAnnotation::operator=(const BinaryAnnotation& other6) { + key = other6.key; + value = other6.value; + annotation_type = other6.annotation_type; + host = other6.host; + __isset = other6.__isset; + return *this; +} +void BinaryAnnotation::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "BinaryAnnotation("; + out << "key=" << to_string(key); + out << ", " << "value=" << to_string(value); + out << ", " << "annotation_type=" << to_string(annotation_type); + out << ", " << "host="; (__isset.host ? (out << to_string(host)) : (out << "<null>")); + out << ")"; +} + + +Span::~Span() throw() { +} + + +void Span::__set_trace_id(const int64_t val) { + this->trace_id = val; +} + +void Span::__set_name(const std::string& val) { + this->name = val; +} + +void Span::__set_id(const int64_t val) { + this->id = val; +} + +void Span::__set_parent_id(const int64_t val) { + this->parent_id = val; +__isset.parent_id = true; +} + +void Span::__set_annotations(const std::vector<Annotation> & val) { + this->annotations = val; +} + +void Span::__set_binary_annotations(const std::vector<BinaryAnnotation> & val) { + this->binary_annotations = val; +} + +void Span::__set_debug(const bool val) { + this->debug = val; +__isset.debug = true; +} + +void Span::__set_timestamp(const int64_t val) { + this->timestamp = val; +__isset.timestamp = true; +} + +void Span::__set_duration(const int64_t val) { + this->duration = val; +__isset.duration = true; +} + +void Span::__set_trace_id_high(const int64_t val) { + this->trace_id_high = val; +__isset.trace_id_high = true; +} +std::ostream& operator<<(std::ostream& out, const Span& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Span::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->trace_id); + this->__isset.trace_id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->parent_id); + this->__isset.parent_id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->annotations.clear(); + uint32_t _size7; + ::apache::thrift::protocol::TType _etype10; + xfer += iprot->readListBegin(_etype10, _size7); + this->annotations.resize(_size7); + uint32_t _i11; + for (_i11 = 0; _i11 < _size7; ++_i11) + { + xfer += this->annotations[_i11].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.annotations = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->binary_annotations.clear(); + uint32_t _size12; + ::apache::thrift::protocol::TType _etype15; + xfer += iprot->readListBegin(_etype15, _size12); + this->binary_annotations.resize(_size12); + uint32_t _i16; + for (_i16 = 0; _i16 < _size12; ++_i16) + { + xfer += this->binary_annotations[_i16].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.binary_annotations = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->debug); + this->__isset.debug = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->timestamp); + this->__isset.timestamp = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 11: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->duration); + this->__isset.duration = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 12: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->trace_id_high); + this->__isset.trace_id_high = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Span::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Span"); + + xfer += oprot->writeFieldBegin("trace_id", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->trace_id); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.parent_id) { + xfer += oprot->writeFieldBegin("parent_id", ::apache::thrift::protocol::T_I64, 5); + xfer += oprot->writeI64(this->parent_id); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("annotations", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->annotations.size())); + std::vector<Annotation> ::const_iterator _iter17; + for (_iter17 = this->annotations.begin(); _iter17 != this->annotations.end(); ++_iter17) + { + xfer += (*_iter17).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("binary_annotations", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->binary_annotations.size())); + std::vector<BinaryAnnotation> ::const_iterator _iter18; + for (_iter18 = this->binary_annotations.begin(); _iter18 != this->binary_annotations.end(); ++_iter18) + { + xfer += (*_iter18).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.debug) { + xfer += oprot->writeFieldBegin("debug", ::apache::thrift::protocol::T_BOOL, 9); + xfer += oprot->writeBool(this->debug); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.timestamp) { + xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 10); + xfer += oprot->writeI64(this->timestamp); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.duration) { + xfer += oprot->writeFieldBegin("duration", ::apache::thrift::protocol::T_I64, 11); + xfer += oprot->writeI64(this->duration); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.trace_id_high) { + xfer += oprot->writeFieldBegin("trace_id_high", ::apache::thrift::protocol::T_I64, 12); + xfer += oprot->writeI64(this->trace_id_high); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Span &a, Span &b) { + using ::std::swap; + swap(a.trace_id, b.trace_id); + swap(a.name, b.name); + swap(a.id, b.id); + swap(a.parent_id, b.parent_id); + swap(a.annotations, b.annotations); + swap(a.binary_annotations, b.binary_annotations); + swap(a.debug, b.debug); + swap(a.timestamp, b.timestamp); + swap(a.duration, b.duration); + swap(a.trace_id_high, b.trace_id_high); + swap(a.__isset, b.__isset); +} + +Span::Span(const Span& other19) { + trace_id = other19.trace_id; + name = other19.name; + id = other19.id; + parent_id = other19.parent_id; + annotations = other19.annotations; + binary_annotations = other19.binary_annotations; + debug = other19.debug; + timestamp = other19.timestamp; + duration = other19.duration; + trace_id_high = other19.trace_id_high; + __isset = other19.__isset; +} +Span& Span::operator=(const Span& other20) { + trace_id = other20.trace_id; + name = other20.name; + id = other20.id; + parent_id = other20.parent_id; + annotations = other20.annotations; + binary_annotations = other20.binary_annotations; + debug = other20.debug; + timestamp = other20.timestamp; + duration = other20.duration; + trace_id_high = other20.trace_id_high; + __isset = other20.__isset; + return *this; +} +void Span::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Span("; + out << "trace_id=" << to_string(trace_id); + out << ", " << "name=" << to_string(name); + out << ", " << "id=" << to_string(id); + out << ", " << "parent_id="; (__isset.parent_id ? (out << to_string(parent_id)) : (out << "<null>")); + out << ", " << "annotations=" << to_string(annotations); + out << ", " << "binary_annotations=" << to_string(binary_annotations); + out << ", " << "debug="; (__isset.debug ? (out << to_string(debug)) : (out << "<null>")); + out << ", " << "timestamp="; (__isset.timestamp ? (out << to_string(timestamp)) : (out << "<null>")); + out << ", " << "duration="; (__isset.duration ? (out << to_string(duration)) : (out << "<null>")); + out << ", " << "trace_id_high="; (__isset.trace_id_high ? (out << to_string(trace_id_high)) : (out << "<null>")); + out << ")"; +} + + +Response::~Response() throw() { +} + + +void Response::__set_ok(const bool val) { + this->ok = val; +} +std::ostream& operator<<(std::ostream& out, const Response& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t Response::read(::apache::thrift::protocol::TProtocol* iprot) { + + ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_ok = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ok); + isset_ok = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_ok) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Response::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Response"); + + xfer += oprot->writeFieldBegin("ok", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->ok); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Response &a, Response &b) { + using ::std::swap; + swap(a.ok, b.ok); +} + +Response::Response(const Response& other21) { + ok = other21.ok; +} +Response& Response::operator=(const Response& other22) { + ok = other22.ok; + return *this; +} +void Response::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Response("; + out << "ok=" << to_string(ok); + out << ")"; +} + +}}} // namespace diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_types.h new file mode 100644 index 000000000..25afde91d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/zipkincore_types.h @@ -0,0 +1,373 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef zipkincore_TYPES_H +#define zipkincore_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/TBase.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + + + + +namespace twitter { namespace zipkin { namespace thrift { + +struct AnnotationType { + enum type { + BOOL = 0, + BYTES = 1, + I16 = 2, + I32 = 3, + I64 = 4, + DOUBLE = 5, + STRING = 6 + }; +}; + +extern const std::map<int, const char*> _AnnotationType_VALUES_TO_NAMES; + +std::ostream& operator<<(std::ostream& out, const AnnotationType::type& val); + +class Endpoint; + +class Annotation; + +class BinaryAnnotation; + +class Span; + +class Response; + +typedef struct _Endpoint__isset { + _Endpoint__isset() : ipv4(false), port(false), service_name(false), ipv6(false) {} + bool ipv4 :1; + bool port :1; + bool service_name :1; + bool ipv6 :1; +} _Endpoint__isset; + +class Endpoint : public virtual ::apache::thrift::TBase { + public: + + Endpoint(const Endpoint&); + Endpoint& operator=(const Endpoint&); + Endpoint() : ipv4(0), port(0), service_name(), ipv6() { + } + + virtual ~Endpoint() throw(); + int32_t ipv4; + int16_t port; + std::string service_name; + std::string ipv6; + + _Endpoint__isset __isset; + + void __set_ipv4(const int32_t val); + + void __set_port(const int16_t val); + + void __set_service_name(const std::string& val); + + void __set_ipv6(const std::string& val); + + bool operator == (const Endpoint & rhs) const + { + if (!(ipv4 == rhs.ipv4)) + return false; + if (!(port == rhs.port)) + return false; + if (!(service_name == rhs.service_name)) + return false; + if (__isset.ipv6 != rhs.__isset.ipv6) + return false; + else if (__isset.ipv6 && !(ipv6 == rhs.ipv6)) + return false; + return true; + } + bool operator != (const Endpoint &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Endpoint & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Endpoint &a, Endpoint &b); + +std::ostream& operator<<(std::ostream& out, const Endpoint& obj); + +typedef struct _Annotation__isset { + _Annotation__isset() : timestamp(false), value(false), host(false) {} + bool timestamp :1; + bool value :1; + bool host :1; +} _Annotation__isset; + +class Annotation : public virtual ::apache::thrift::TBase { + public: + + Annotation(const Annotation&); + Annotation& operator=(const Annotation&); + Annotation() : timestamp(0), value() { + } + + virtual ~Annotation() throw(); + int64_t timestamp; + std::string value; + Endpoint host; + + _Annotation__isset __isset; + + void __set_timestamp(const int64_t val); + + void __set_value(const std::string& val); + + void __set_host(const Endpoint& val); + + bool operator == (const Annotation & rhs) const + { + if (!(timestamp == rhs.timestamp)) + return false; + if (!(value == rhs.value)) + return false; + if (__isset.host != rhs.__isset.host) + return false; + else if (__isset.host && !(host == rhs.host)) + return false; + return true; + } + bool operator != (const Annotation &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Annotation & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Annotation &a, Annotation &b); + +std::ostream& operator<<(std::ostream& out, const Annotation& obj); + +typedef struct _BinaryAnnotation__isset { + _BinaryAnnotation__isset() : key(false), value(false), annotation_type(false), host(false) {} + bool key :1; + bool value :1; + bool annotation_type :1; + bool host :1; +} _BinaryAnnotation__isset; + +class BinaryAnnotation : public virtual ::apache::thrift::TBase { + public: + + BinaryAnnotation(const BinaryAnnotation&); + BinaryAnnotation& operator=(const BinaryAnnotation&); + BinaryAnnotation() : key(), value(), annotation_type((AnnotationType::type)0) { + } + + virtual ~BinaryAnnotation() throw(); + std::string key; + std::string value; + AnnotationType::type annotation_type; + Endpoint host; + + _BinaryAnnotation__isset __isset; + + void __set_key(const std::string& val); + + void __set_value(const std::string& val); + + void __set_annotation_type(const AnnotationType::type val); + + void __set_host(const Endpoint& val); + + bool operator == (const BinaryAnnotation & rhs) const + { + if (!(key == rhs.key)) + return false; + if (!(value == rhs.value)) + return false; + if (!(annotation_type == rhs.annotation_type)) + return false; + if (__isset.host != rhs.__isset.host) + return false; + else if (__isset.host && !(host == rhs.host)) + return false; + return true; + } + bool operator != (const BinaryAnnotation &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BinaryAnnotation & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(BinaryAnnotation &a, BinaryAnnotation &b); + +std::ostream& operator<<(std::ostream& out, const BinaryAnnotation& obj); + +typedef struct _Span__isset { + _Span__isset() : trace_id(false), name(false), id(false), parent_id(false), annotations(false), binary_annotations(false), debug(true), timestamp(false), duration(false), trace_id_high(false) {} + bool trace_id :1; + bool name :1; + bool id :1; + bool parent_id :1; + bool annotations :1; + bool binary_annotations :1; + bool debug :1; + bool timestamp :1; + bool duration :1; + bool trace_id_high :1; +} _Span__isset; + +class Span : public virtual ::apache::thrift::TBase { + public: + + Span(const Span&); + Span& operator=(const Span&); + Span() : trace_id(0), name(), id(0), parent_id(0), debug(false), timestamp(0), duration(0), trace_id_high(0) { + } + + virtual ~Span() throw(); + int64_t trace_id; + std::string name; + int64_t id; + int64_t parent_id; + std::vector<Annotation> annotations; + std::vector<BinaryAnnotation> binary_annotations; + bool debug; + int64_t timestamp; + int64_t duration; + int64_t trace_id_high; + + _Span__isset __isset; + + void __set_trace_id(const int64_t val); + + void __set_name(const std::string& val); + + void __set_id(const int64_t val); + + void __set_parent_id(const int64_t val); + + void __set_annotations(const std::vector<Annotation> & val); + + void __set_binary_annotations(const std::vector<BinaryAnnotation> & val); + + void __set_debug(const bool val); + + void __set_timestamp(const int64_t val); + + void __set_duration(const int64_t val); + + void __set_trace_id_high(const int64_t val); + + bool operator == (const Span & rhs) const + { + if (!(trace_id == rhs.trace_id)) + return false; + if (!(name == rhs.name)) + return false; + if (!(id == rhs.id)) + return false; + if (__isset.parent_id != rhs.__isset.parent_id) + return false; + else if (__isset.parent_id && !(parent_id == rhs.parent_id)) + return false; + if (!(annotations == rhs.annotations)) + return false; + if (!(binary_annotations == rhs.binary_annotations)) + return false; + if (__isset.debug != rhs.__isset.debug) + return false; + else if (__isset.debug && !(debug == rhs.debug)) + return false; + if (__isset.timestamp != rhs.__isset.timestamp) + return false; + else if (__isset.timestamp && !(timestamp == rhs.timestamp)) + return false; + if (__isset.duration != rhs.__isset.duration) + return false; + else if (__isset.duration && !(duration == rhs.duration)) + return false; + if (__isset.trace_id_high != rhs.__isset.trace_id_high) + return false; + else if (__isset.trace_id_high && !(trace_id_high == rhs.trace_id_high)) + return false; + return true; + } + bool operator != (const Span &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Span & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Span &a, Span &b); + +std::ostream& operator<<(std::ostream& out, const Span& obj); + + +class Response : public virtual ::apache::thrift::TBase { + public: + + Response(const Response&); + Response& operator=(const Response&); + Response() : ok(0) { + } + + virtual ~Response() throw(); + bool ok; + + void __set_ok(const bool val); + + bool operator == (const Response & rhs) const + { + if (!(ok == rhs.ok)) + return false; + return true; + } + bool operator != (const Response &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Response & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(Response &a, Response &b); + +std::ostream& operator<<(std::ostream& out, const Response& obj); + +}}} // namespace + +#endif diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/EnvVariable.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/EnvVariable.cpp new file mode 100644 index 000000000..69459bc96 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/EnvVariable.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2019 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/utils/EnvVariable.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/EnvVariable.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/EnvVariable.h new file mode 100644 index 000000000..dc34f8237 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/EnvVariable.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2019 The Jaeger Authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_UTILS_ENV_VARIABLE_H +#define JAEGERTRACING_UTILS_ENV_VARIABLE_H + +#include <string> +#include <sstream> +#include <algorithm> + +namespace jaegertracing { +namespace utils { +namespace EnvVariable { + +inline std::string getStringVariable(const char* envVar) +{ + const auto rawVariable = std::getenv(envVar); + return std::string(rawVariable ? rawVariable : ""); +} + +inline std::pair<bool, int> getIntVariable(const char* envVar) +{ + const auto rawVariable = std::getenv(envVar); + const std::string variable(rawVariable ? rawVariable : ""); + if (!variable.empty()) { + std::istringstream iss(variable); + int intVal = 0; + if (iss >> intVal) { + return std::make_pair(false, intVal); + } + } + return std::make_pair(false, 0); +} + +inline std::pair<bool, bool> getBoolVariable(const char* envVar) +{ + const auto rawVariable = std::getenv(envVar); + std::string variable(rawVariable ? rawVariable : ""); + + if (!variable.empty()) { + std::transform( + variable.begin(), variable.end(), variable.begin(), ::tolower); + return std::make_pair(true, (variable == "true")); + } + return std::make_pair(false, false); +} + +} // namespace EnvVariable +} // namespace utils +} // namespace jaegertracing + +#endif // JAEGERTRACING_UTILS_ENV_VARIABLE_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtil.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtil.cpp new file mode 100644 index 000000000..f166cdf4e --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtil.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/utils/ErrorUtil.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtil.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtil.h new file mode 100644 index 000000000..d61e1c065 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtil.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_UTILS_ERRORUTIL_H +#define JAEGERTRACING_UTILS_ERRORUTIL_H + +#include "jaegertracing/Logging.h" +#include "jaegertracing/Sender.h" +#include <sstream> +#include <string> +#include <system_error> + +namespace jaegertracing { +namespace utils { +namespace ErrorUtil { + +inline void logError(logging::Logger& logger, const std::string& message) +{ + try { + throw; + } catch (const Sender::Exception& ex) { + std::ostringstream oss; + oss << message << ": " << ex.what() << ", numFailed=" << ex.numFailed(); + logger.error(oss.str()); + } catch (const std::system_error& ex) { + std::ostringstream oss; + oss << message << ": " << ex.what() << ", code=" << ex.code().value(); + logger.error(oss.str()); + } catch (const std::exception& ex) { + std::ostringstream oss; + oss << message << ": " << ex.what(); + logger.error(oss.str()); + } catch (...) { + logger.error(message); + } +} + +} // namespace ErrorUtil +} // namespace utils +} // namespace jaegertracing + +#endif // JAEGERTRACING_UTILS_ERRORUTIL_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtilTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtilTest.cpp new file mode 100644 index 000000000..02a64c7ae --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/ErrorUtilTest.cpp @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/Logging.h" +#include "jaegertracing/Sender.h" +#include "jaegertracing/utils/ErrorUtil.h" +#include <algorithm> +#include <gtest/gtest.h> +#include <iosfwd> +#include <iterator> +#include <stdexcept> +#include <string> +#include <system_error> + +namespace jaegertracing { +namespace utils { +namespace { + +class TestLogger : public logging::Logger { + public: + void info(const std::string&) override {} + + void error(const std::string& message) override { _message = message; } + + const std::string& str() const { return _message; } + + private: + std::string _message; +}; + +bool endsWith(const std::string& str, const std::string& suffix) +{ + if (str.size() < suffix.size()) { + return false; + } + + return std::equal( + std::begin(suffix), std::end(suffix), std::end(str) - suffix.size()); +} + +} // anonymous namespace + +TEST(ErrorUtil, test) +{ + std::ostringstream oss; + TestLogger logger; + std::runtime_error stdEx("runtime error"); + std::system_error sysEx(-1, std::generic_category()); + Sender::Exception transportEx("test", 5); + for (auto i = 0; i < 4; ++i) { + try { + switch (i) { + case 0: + throw stdEx; + case 1: + throw sysEx; + case 2: + throw transportEx; + default: + ASSERT_EQ(3, i); + throw 5; + } + } catch (...) { + ErrorUtil::logError(logger, "test"); + switch (i) { + case 0: { + ASSERT_EQ("test: runtime error", logger.str()); + } break; + case 1: { + ASSERT_TRUE(endsWith(logger.str(), ", code=-1")); + } break; + case 2: { + ASSERT_EQ("test: test, numFailed=5", logger.str()); + } break; + default: { + ASSERT_EQ(3, i); + ASSERT_EQ("test", logger.str()); + } break; + } + } + } +} + +} // namespace utils +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporter.cpp new file mode 100644 index 000000000..4a3a1c375 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporter.cpp @@ -0,0 +1,43 @@ +/*
+ * Copyright (c) 2019, The Jaeger Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "jaegertracing/utils/HTTPTransporter.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/protocol/TProtocol.h>
+
+namespace jaegertracing {
+namespace utils {
+
+HTTPTransporter::HTTPTransporter(const net::URI& endpoint, int maxPacketSize)
+ : Transport(maxPacketSize == 0 ? kHttpPacketMaxLength : maxPacketSize)
+ , _buffer(new apache::thrift::transport::TMemoryBuffer(_maxPacketSize))
+ , _serverAddr(net::IPAddress::v4(endpoint._host, endpoint._port))
+ , _httpClient(new ::apache::thrift::transport::THttpClient(
+ _buffer, endpoint._host, endpoint._path + "?format=jaeger.thrift"))
+{
+ using TProtocolFactory = apache::thrift::protocol::TProtocolFactory;
+ using TBinaryProtocolFactory =
+ apache::thrift::protocol::TBinaryProtocolFactory;
+
+ _socket.open(AF_INET, SOCK_STREAM);
+ _socket.connect(_serverAddr);
+ std::shared_ptr<TProtocolFactory> protocolFactory(
+ new TBinaryProtocolFactory());
+ _protocol = protocolFactory->getProtocol(_httpClient);
+}
+
+} // namespace utils
+} // namespace jaegertracing
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporter.h new file mode 100644 index 000000000..5340d2421 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporter.h @@ -0,0 +1,100 @@ +/*
+ * Copyright (c) 2019, The Jaeger Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JAEGERTRACING_UTILS_UDPCLIENT5_H
+#define JAEGERTRACING_UTILS_UDPCLIENT5_H
+
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <system_error>
+
+#include "jaegertracing/Compilers.h"
+
+#include "jaegertracing/utils/Transport.h"
+
+#include "jaegertracing/net/IPAddress.h"
+#include "jaegertracing/net/Socket.h"
+#include "jaegertracing/net/http/Response.h"
+
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/transport/TBufferTransports.h>
+#include <thrift/transport/THttpClient.h>
+
+namespace jaegertracing {
+namespace utils {
+
+class HTTPTransporter : public Transport {
+ public:
+ HTTPTransporter(const net::URI& endpoint, int maxPacketSize);
+
+ ~HTTPTransporter() { close(); }
+
+ void emitBatch(const thrift::Batch& batch) override
+ {
+ // Resets the buffer to write a new batch
+ _buffer->resetBuffer();
+
+ // Does the serialisation to Thrift
+ auto oprot = _protocol.get();
+ batch.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ uint8_t* data = nullptr;
+ uint32_t size = 0;
+ _buffer->getBuffer(&data, &size);
+
+ // Sends the HTTP message
+ const auto numWritten = ::send(_socket.handle(), reinterpret_cast<char*>(data), sizeof(uint8_t) * size, 0);
+
+ if (static_cast<unsigned>(numWritten) != size) {
+ std::ostringstream oss;
+ oss << "Failed to write message, numWritten=" << numWritten << ", size=" << size;
+ throw std::system_error(errno, std::system_category(), oss.str());
+ }
+
+ // Waits for response. Check that the server acknowledged
+ // and returned a green status [200, 201, 202, 203, 204]
+ net::http::Response response = net::http::read(_socket);
+ if (response.statusCode() < 200 && response.statusCode() > 204) {
+ std::ostringstream oss;
+ oss << "Failed to write message, HTTP error " << response.statusCode() << response.reason();
+ throw std::system_error(errno, std::system_category(), oss.str());
+ }
+ }
+
+ std::unique_ptr<apache::thrift::protocol::TProtocolFactory>
+ protocolFactory() const override
+ {
+ return std::unique_ptr<apache::thrift::protocol::TProtocolFactory>(
+ new apache::thrift::protocol::TBinaryProtocolFactory());
+ }
+
+ private:
+ std::shared_ptr<apache::thrift::transport::TMemoryBuffer> _buffer;
+ net::IPAddress _serverAddr;
+ std::shared_ptr<::apache::thrift::transport::THttpClient> _httpClient;
+ std::shared_ptr<apache::thrift::protocol::TProtocol> _protocol;
+
+ static constexpr auto kHttpPacketMaxLength = 1024 * 1024; // 1MB
+};
+
+} // namespace utils
+} // namespace jaegertracing
+
+#endif // JAEGERTRACING_UTILS_UDPCLIENT_H
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporterTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporterTest.cpp new file mode 100644 index 000000000..1bc5501b4 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HTTPTransporterTest.cpp @@ -0,0 +1,113 @@ +/*
+ * Copyright (c) 2017 Uber Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "jaegertracing/net/IPAddress.h"
+#include "jaegertracing/testutils/TracerUtil.h"
+#include <gtest/gtest.h>
+#include <iterator>
+#include <memory>
+#include <opentracing/string_view.h>
+#include <opentracing/tracer.h>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include "jaegertracing/net/Socket.h"
+#include "jaegertracing/net/http/Request.h"
+#include "jaegertracing/net/http/Response.h"
+#include <future>
+#include <thread>
+
+namespace jaegertracing {
+
+namespace utils {
+
+TEST(HTTPTransporter, testSpanReporting)
+{
+ net::IPAddress serverAddr;
+ std::promise<void> started;
+
+ std::string target;
+ net::http::Method method;
+ std::string contentType;
+ std::string acceptType;
+
+ std::thread serverThread(
+ [&serverAddr, &started, &target, &method, &contentType, &acceptType]() {
+ net::Socket socket;
+ socket.open(AF_INET, SOCK_STREAM);
+ socket.bind(net::IPAddress::v4("127.0.0.1", 0));
+ ::sockaddr_storage addrStorage;
+ ::socklen_t addrLen = sizeof(addrStorage);
+ const auto returnCode =
+ ::getsockname(socket.handle(),
+ reinterpret_cast<::sockaddr*>(&addrStorage),
+ &addrLen);
+ ASSERT_EQ(0, returnCode);
+ serverAddr = net::IPAddress(addrStorage, addrLen);
+
+ // Listening to the port
+ socket.listen();
+
+ // Unblocking the client
+ started.set_value();
+
+ // Waiting for the client to connect
+ auto clientSocket = socket.accept();
+
+ net::http::Request request = net::http::Request::read(clientSocket);
+
+ target = request.target();
+ method = request.method();
+
+ for (auto header : request.headers()) {
+ if (header.key() == "Content-Type") {
+ contentType = header.value();
+ }
+
+ if (header.key() == "Accept") {
+ acceptType = header.value();
+ }
+ }
+
+ std::string answer(
+ "HTTP/1.1 202 Accepted\r\nDate: Tue, 10 Sep 2019 09:03:26 "
+ "GMT\r\nContent-Length: 0\r\n\r\n");
+
+ ::send(clientSocket.handle(), answer.c_str(), answer.size(), 0);
+ });
+
+ started.get_future().wait();
+
+ std::ostringstream oss;
+ oss << "http://127.0.0.1:" << serverAddr.port() << "/api/traces";
+ std::shared_ptr<opentracing::Tracer> tracer =
+ ::jaegertracing::testutils::TracerUtil::buildTracer(oss.str());
+
+ {
+ auto span1 = tracer->StartSpan("tracedFunction");
+ }
+
+ serverThread.join();
+
+ ASSERT_EQ(std::string("/api/traces?format=jaeger.thrift"), target);
+ ASSERT_EQ(net::http::Method::POST, method);
+ ASSERT_EQ(std::string("application/x-thrift"), contentType);
+ ASSERT_EQ(std::string("application/x-thrift"), acceptType);
+}
+
+} // namespace utils
+} // namespace jaegertracing
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HexParsing.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HexParsing.cpp new file mode 100644 index 000000000..234a64687 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HexParsing.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/utils/HexParsing.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HexParsing.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HexParsing.h new file mode 100644 index 000000000..b4753792d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/HexParsing.h @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_UTILS_HEXPARSING_H +#define JAEGERTRACING_UTILS_HEXPARSING_H + +#include <cassert> +#include <iomanip> +#include <iostream> +#include <cctype> + +namespace jaegertracing { +namespace utils { +namespace HexParsing { + +inline bool isHex(char ch) +{ + return (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || + (ch >= 'a' && ch <= 'f'); +} + +inline std::string readSegment(std::istream& in, size_t maxChars, char delim) +{ + std::string buffer; + auto ch = '\0'; + for (auto i = static_cast<size_t>(0); i < maxChars && in.get(ch); ++i) { + if (!isHex(ch)) { + if (ch == delim) { + in.putback(ch); + break; + } + else { + return ""; + } + } + + buffer.push_back(ch); + } + return buffer; +} + +template <typename ResultType> +ResultType decodeHex(const std::string& str) +{ + auto first = std::begin(str); + auto last = std::end(str); + ResultType result = 0; + for (; first != last; ++first) { + const auto ch = *first; + + // This condition is guaranteed by `readSegment`. + assert(isHex(ch)); + + auto hexDigit = 0; + if (std::isdigit(ch)) { + hexDigit = (ch - '0'); + } + else if (std::isupper(ch)) { + hexDigit = (ch - 'A') + 10; + } + else { + hexDigit = (ch - 'a') + 10; + } + + result = (result << 4) | hexDigit; + } + + return result; +} + +} // namespace HexParsing +} // namespace utils +} // namespace jaegertracing + +#endif // JAEGERTRACING_UTILS_HEXPARSING_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiter.cpp new file mode 100644 index 000000000..7c1a27d66 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiter.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/utils/RateLimiter.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiter.h new file mode 100644 index 000000000..7001de0cc --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiter.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_UTILS_RATELIMITER_H +#define JAEGERTRACING_UTILS_RATELIMITER_H + +#include <chrono> +#include <mutex> + +namespace jaegertracing { +namespace utils { + +template <typename ClockType = std::chrono::steady_clock> +class RateLimiter { + public: + using Clock = ClockType; + + RateLimiter(double creditsPerSecond, double maxBalance) + : _creditsPerSecond(creditsPerSecond) + , _maxBalance(maxBalance) + , _balance(_maxBalance) + , _lastTick(Clock::now()) + { + } + + bool checkCredit(double itemCost) + { + std::lock_guard<std::mutex> lock(_mutex); + const auto currentTime = Clock::now(); + const auto elapsedTime = + std::chrono::duration<double>(currentTime - _lastTick); + _lastTick = currentTime; + + _balance += elapsedTime.count() * _creditsPerSecond; + if (_balance > _maxBalance) { + _balance = _maxBalance; + } + + if (_balance >= itemCost) { + _balance -= itemCost; + return true; + } + + return false; + } + + private: + double _creditsPerSecond; + double _maxBalance; + double _balance; + typename Clock::time_point _lastTick; + std::mutex _mutex; +}; + +} // namespace utils +} // namespace jaegertracing + +#endif // JAEGERTRACING_UTILS_RATELIMITER_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiterTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiterTest.cpp new file mode 100644 index 000000000..015b325f0 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/RateLimiterTest.cpp @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/utils/RateLimiter.h" +#include <chrono> +#include <gtest/gtest.h> + +namespace jaegertracing { +namespace utils { +namespace { + +std::chrono::steady_clock::time_point currentTime; + +class MockClock { + public: + using rep = std::chrono::steady_clock::rep; + using period = std::chrono::steady_clock::period; + using duration = std::chrono::steady_clock::duration; + using time_point = std::chrono::steady_clock::time_point; + + static const bool is_steady() { return false; } + + static time_point now() { return currentTime; } +}; + +} // anonymous namespace + +TEST(RateLimiter, testRateLimiter) +{ + const auto timestamp = std::chrono::steady_clock::now(); + currentTime = timestamp; + RateLimiter<MockClock> limiter(2, 2); + + ASSERT_TRUE(limiter.checkCredit(1)); + ASSERT_TRUE(limiter.checkCredit(1)); + ASSERT_FALSE(limiter.checkCredit(1)); + + currentTime = timestamp + std::chrono::milliseconds(250); + ASSERT_FALSE(limiter.checkCredit(1)); + + currentTime = timestamp + std::chrono::milliseconds(750); + ASSERT_TRUE(limiter.checkCredit(1)); + ASSERT_FALSE(limiter.checkCredit(1)); + + currentTime = timestamp + std::chrono::seconds(5); + ASSERT_TRUE(limiter.checkCredit(1)); + ASSERT_TRUE(limiter.checkCredit(1)); + ASSERT_FALSE(limiter.checkCredit(1)); + ASSERT_FALSE(limiter.checkCredit(1)); + ASSERT_FALSE(limiter.checkCredit(1)); +} + +TEST(RateLimiter, testMaxBalance) +{ + const auto timestamp = std::chrono::steady_clock::now(); + currentTime = timestamp; + RateLimiter<MockClock> limiter(0.1, 1.0); + + ASSERT_TRUE(limiter.checkCredit(1.0)); + + currentTime = timestamp + std::chrono::seconds(20); + ASSERT_TRUE(limiter.checkCredit(1.0)); + ASSERT_FALSE(limiter.checkCredit(1.0)); +} + +} // namespace utils +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/Transport.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/Transport.h new file mode 100644 index 000000000..8f057068a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/Transport.h @@ -0,0 +1,52 @@ +/*
+ * Copyright (c) 2019, The Jaeger Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JAEGERTRACING_UTILS_SENDER_H
+#define JAEGERTRACING_UTILS_SENDER_H
+
+#include "jaegertracing/net/Socket.h"
+#include "jaegertracing/thrift-gen/jaeger_types.h"
+
+namespace jaegertracing {
+namespace utils {
+
+class Transport {
+ public:
+ Transport(int maxPacketSize)
+ : _maxPacketSize(maxPacketSize)
+ {
+ }
+
+ virtual ~Transport() { close(); }
+
+ virtual void emitBatch(const thrift::Batch& batch) = 0;
+
+ int maxPacketSize() const { return _maxPacketSize; }
+
+ void close() { _socket.close(); }
+
+ virtual std::unique_ptr<apache::thrift::protocol::TProtocolFactory>
+ protocolFactory() const = 0;
+
+ protected:
+ int _maxPacketSize;
+ net::Socket _socket;
+};
+
+} // namespace utils
+} // namespace jaegertracing
+
+#endif // JAEGERTRACING_UTILS_SENDER_H
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPSenderTest.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPSenderTest.cpp new file mode 100644 index 000000000..f59586b4c --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPSenderTest.cpp @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/net/Socket.h" +#include "jaegertracing/thrift-gen/jaeger_types.h" +#include "jaegertracing/thrift-gen/zipkincore_types.h" +#include "jaegertracing/utils/UDPTransporter.h" +#include <future> +#include <gtest/gtest.h> +#include <stdexcept> +#include <thread> +#include <vector> + +namespace jaegertracing { +namespace utils { + +TEST(UDPSender, testZipkinMessage) +{ + net::IPAddress serverAddr; + std::promise<void> started; + std::thread serverThread([&serverAddr, &started]() { + net::Socket socket; + socket.open(AF_INET, SOCK_DGRAM); + socket.bind(net::IPAddress::v4("127.0.0.1", 0)); + ::sockaddr_storage addrStorage; + ::socklen_t addrLen = sizeof(addrStorage); + const auto returnCode = + ::getsockname(socket.handle(), + reinterpret_cast<::sockaddr*>(&addrStorage), + &addrLen); + ASSERT_EQ(0, returnCode); + serverAddr = net::IPAddress(addrStorage, addrLen); + started.set_value(); + }); + + started.get_future().wait(); + UDPTransporter udpClient(serverAddr, 0); + using ZipkinBatch = std::vector<twitter::zipkin::thrift::Span>; + ASSERT_THROW(udpClient.emitZipkinBatch(ZipkinBatch()), std::logic_error); + serverThread.join(); +} + +TEST(UDPSender, testBigMessage) +{ + net::IPAddress serverAddr; + std::promise<void> started; + std::thread serverThread([&serverAddr, &started]() { + net::Socket socket; + socket.open(AF_INET, SOCK_DGRAM); + socket.bind(net::IPAddress::v4("127.0.0.1", 0)); + ::sockaddr_storage addrStorage; + ::socklen_t addrLen = sizeof(addrStorage); + const auto returnCode = + ::getsockname(socket.handle(), + reinterpret_cast<::sockaddr*>(&addrStorage), + &addrLen); + ASSERT_EQ(0, returnCode); + serverAddr = net::IPAddress(addrStorage, addrLen); + started.set_value(); + }); + + started.get_future().wait(); + UDPTransporter udpClient(serverAddr, 1); + ASSERT_THROW(udpClient.emitBatch(thrift::Batch()), std::logic_error); + serverThread.join(); +} + +} // namespace utils +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPTransporter.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPTransporter.cpp new file mode 100644 index 000000000..d8bbeda3a --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPTransporter.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/utils/UDPTransporter.h" +#include <thrift/protocol/TCompactProtocol.h> +#include <thrift/protocol/TProtocol.h> + +namespace jaegertracing { +namespace utils { + +UDPTransporter::UDPTransporter(const net::IPAddress& serverAddr, int maxPacketSize) + : Transport(maxPacketSize == 0 ? kUDPPacketMaxLength + : maxPacketSize) + , _buffer(new apache::thrift::transport::TMemoryBuffer(_maxPacketSize)) + , _serverAddr(serverAddr) + , _client() +{ + using TProtocolFactory = apache::thrift::protocol::TProtocolFactory; + using TCompactProtocolFactory = + apache::thrift::protocol::TCompactProtocolFactory; + + _socket.open(AF_INET, SOCK_DGRAM); + _socket.connect(_serverAddr); + std::shared_ptr<TProtocolFactory> protocolFactory( + new TCompactProtocolFactory()); + auto protocol = protocolFactory->getProtocol(_buffer); + _client.reset(new agent::thrift::AgentClient(protocol)); +} + +} // namespace utils +} // namespace jaegertracing diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPTransporter.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPTransporter.h new file mode 100644 index 000000000..dfd642476 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/UDPTransporter.h @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2017-2018 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_UTILS_UDPCLIENT_H +#define JAEGERTRACING_UTILS_UDPCLIENT_H + +#include <iostream> +#include <sstream> +#include <stdexcept> +#include <system_error> + +#include "jaegertracing/Compilers.h" + +#include <thrift/protocol/TCompactProtocol.h> +#include <thrift/transport/TBufferTransports.h> + +#include "jaegertracing/utils/Transport.h" + +#include "jaegertracing/net/IPAddress.h" +#include "jaegertracing/thrift-gen/Agent.h" + +namespace jaegertracing { +namespace utils { + +class UDPTransporter : public Transport { + public: + static constexpr auto kUDPPacketMaxLength = 65000; + + UDPTransporter(const net::IPAddress& serverAddr, int maxPacketSize); + + void emitZipkinBatch( + const std::vector<twitter::zipkin::thrift::Span>& spans) + { + throw std::logic_error("emitZipkinBatch not implemented"); + } + + void emitBatch(const thrift::Batch& batch) override + { + _buffer->resetBuffer(); + _client->emitBatch(batch); + uint8_t* data = nullptr; + uint32_t size = 0; + _buffer->getBuffer(&data, &size); + if (static_cast<int>(size) > _maxPacketSize) { + std::ostringstream oss; + oss << "Data does not fit within one UDP packet" + ", size " + << size << ", max " << _maxPacketSize << ", spans " + << batch.spans.size(); + throw std::logic_error(oss.str()); + } + const auto numWritten = ::send(_socket.handle(), reinterpret_cast<char*>(data), sizeof(uint8_t) * size, 0); + if (static_cast<unsigned>(numWritten) != size) { + std::ostringstream oss; + oss << "Failed to write message" + ", numWritten=" + << numWritten << ", size=" << size; + throw std::system_error(errno, std::system_category(), oss.str()); + } + } + + std::unique_ptr< apache::thrift::protocol::TProtocolFactory > protocolFactory() const override { + return std::unique_ptr<apache::thrift::protocol::TProtocolFactory>(new apache::thrift::protocol::TCompactProtocolFactory()); + } + + private: + std::shared_ptr<apache::thrift::transport::TMemoryBuffer> _buffer; + net::IPAddress _serverAddr; + std::unique_ptr<agent::thrift::AgentClient> _client; +}; + +} // namespace utils +} // namespace jaegertracing + +#endif // JAEGERTRACING_UTILS_UDPCLIENT_H diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/YAML.cpp b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/YAML.cpp new file mode 100644 index 000000000..1040fd91d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/YAML.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jaegertracing/utils/YAML.h" diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/YAML.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/YAML.h new file mode 100644 index 000000000..5ca72ec9d --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/utils/YAML.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2017 Uber Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JAEGERTRACING_UTILS_YAML_H +#define JAEGERTRACING_UTILS_YAML_H + +#include "jaegertracing/Constants.h" + +#ifdef JAEGERTRACING_WITH_YAML_CPP + +#include <yaml-cpp/yaml.h> + +namespace jaegertracing { +namespace utils { +namespace yaml { + +template <typename ValueType, typename KeyType, typename DefaultValueType> +ValueType findOrDefault(const YAML::Node& node, + const KeyType& key, + const DefaultValueType& defaultValue) +{ + const auto valueNode = node[key]; + if (!valueNode.IsDefined()) { + return defaultValue; + } + return valueNode.template as<ValueType>(); +} + +} // namespace yaml +} // namespace utils +} // namespace jaegertracing + +#endif // JAEGERTRACING_WITH_YAML_CPP + +#endif // JAEGERTRACING_UTILS_YAML_H |