1 files changed, 206 insertions, 0 deletions
diff --git a/vendor/opentracing/opentracing/src/OpenTracing/StartSpanOptions.php b/vendor/opentracing/opentracing/src/OpenTracing/StartSpanOptions.php
new file mode 100644
index 000000000..28b73ff0a
--- /dev/null
+++ b/vendor/opentracing/opentracing/src/OpenTracing/StartSpanOptions.php
@@ -0,0 +1,206 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTracing;
+
+use DateTime;
+use DateTimeInterface;
+use OpenTracing\InvalidReferencesSetException;
+use OpenTracing\InvalidSpanOptionException;
+
+final class StartSpanOptions
+{
+    /**
+     * @var Reference[]
+     */
+    private $references = [];
+
+    /**
+     * @var array
+     */
+    private $tags = [];
+
+    /**
+     * @var int|float|DateTimeInterface
+     */
+    private $startTime;
+
+    /**
+     * Only used for spans that are actively managed by scope manager.
+     *
+     * @var bool
+     */
+    private $finishSpanOnClose = ScopeManager::DEFAULT_FINISH_SPAN_ON_CLOSE;
+
+    /**
+     * @var bool
+     */
+    private $ignoreActiveSpan = false;
+
+    /**
+     * @param array $options
+     * @return StartSpanOptions
+     * @throws InvalidReferencesSetException when there are inconsistencies about the references
+     * @throws InvalidSpanOptionException when one of the options is invalid
+     */
+    public static function create(array $options): StartSpanOptions
+    {
+        $spanOptions = new self();
+
+        foreach ($options as $key => $value) {
+            switch ($key) {
+                case 'child_of':
+                    if (!empty($spanOptions->references)) {
+                        throw InvalidSpanOptionException::forIncludingBothChildOfAndReferences();
+                    }
+
+                    $spanOptions->references[] = self::buildChildOf($value);
+                    break;
+
+                case 'references':
+                    if (!empty($spanOptions->references)) {
+                        throw InvalidSpanOptionException::forIncludingBothChildOfAndReferences();
+                    }
+
+                    if ($value instanceof Reference) {
+                        $spanOptions->references = [$value];
+                    } elseif (is_array($value)) {
+                        $spanOptions->references = self::buildReferences($value);
+                    } else {
+                        throw InvalidSpanOptionException::forInvalidReferenceSet($value);
+                    }
+
+                    break;
+
+                case 'tags':
+                    if (!is_array($value)) {
+                        throw InvalidSpanOptionException::forInvalidTags($value);
+                    }
+
+                    foreach ($value as $tag => $tagValue) {
+                        if ($tag !== (string)$tag) {
+                            throw InvalidSpanOptionException::forInvalidTag($tag);
+                        }
+
+                        $spanOptions->tags[$tag] = $tagValue;
+                    }
+                    break;
+
+                case 'start_time':
+                    if (is_scalar($value) && !is_numeric($value)) {
+                        throw InvalidSpanOptionException::forInvalidStartTime();
+                    }
+
+                    $spanOptions->startTime = $value;
+                    break;
+
+                case 'finish_span_on_close':
+                    if (!is_bool($value)) {
+                        throw InvalidSpanOptionException::forFinishSpanOnClose($value);
+                    }
+
+                    $spanOptions->finishSpanOnClose = $value;
+                    break;
+
+                case 'ignore_active_span':
+                    if (!is_bool($value)) {
+                        throw InvalidSpanOptionException::forIgnoreActiveSpan($value);
+                    }
+
+                    $spanOptions->ignoreActiveSpan = $value;
+                    break;
+
+                default:
+                    throw InvalidSpanOptionException::forUnknownOption($key);
+            }
+        }
+
+        return $spanOptions;
+    }
+
+    /**
+     * @param Span|SpanContext $parent
+     * @return StartSpanOptions
+     */
+    public function withParent($parent): StartSpanOptions
+    {
+        $newSpanOptions = new StartSpanOptions();
+        $newSpanOptions->references[] = self::buildChildOf($parent);
+        $newSpanOptions->tags = $this->tags;
+        $newSpanOptions->startTime = $this->startTime;
+        $newSpanOptions->finishSpanOnClose = $this->finishSpanOnClose;
+        $newSpanOptions->ignoreActiveSpan = $this->ignoreActiveSpan;
+
+        return $newSpanOptions;
+    }
+
+    /**
+     * @return Reference[]
+     */
+    public function getReferences(): array
+    {
+        return $this->references;
+    }
+
+    /**
+     * @return array
+     */
+    public function getTags(): array
+    {
+        return $this->tags;
+    }
+
+    /**
+     * @return int|float|DateTime|null if returning float or int it should represent
+     * the timestamp (including as many decimal places as you need)
+     */
+    public function getStartTime()
+    {
+        return $this->startTime;
+    }
+
+    /**
+     * @return bool
+     */
+    public function shouldFinishSpanOnClose(): bool
+    {
+        return $this->finishSpanOnClose;
+    }
+
+    /**
+     * @return bool
+     */
+    public function shouldIgnoreActiveSpan(): bool
+    {
+        return $this->ignoreActiveSpan;
+    }
+
+    private static function buildChildOf($value): Reference
+    {
+        if ($value instanceof Span) {
+            return Reference::createForSpan(Reference::CHILD_OF, $value);
+        }
+
+        if ($value instanceof SpanContext) {
+            return new Reference(Reference::CHILD_OF, $value);
+        }
+
+        throw InvalidSpanOptionException::forInvalidChildOf($value);
+    }
+
+    private static function buildReferences(array $referencesArray): array
+    {
+        $references = [];
+
+        foreach ($referencesArray as $reference) {
+            if (!($reference instanceof Reference)) {
+                throw InvalidSpanOptionException::forInvalidReference($reference);
+            }
+
+            $references[] = $reference;
+        }
+
+        return $references;
+    }
+}