{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- |
-- Module      : Gogol.Tracing.Internal.Product
-- Copyright   : (c) 2015-2025 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+gogol@gmail.com>
--               Toni Cebrián <toni@tonicebrian.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Gogol.Tracing.Internal.Product
  ( -- * Annotation
    Annotation (..),
    newAnnotation,

    -- * AttributeValue
    AttributeValue (..),
    newAttributeValue,

    -- * Attributes
    Attributes (..),
    newAttributes,

    -- * Attributes_AttributeMap
    Attributes_AttributeMap (..),
    newAttributes_AttributeMap,

    -- * BatchWriteSpansRequest
    BatchWriteSpansRequest (..),
    newBatchWriteSpansRequest,

    -- * Empty
    Empty (..),
    newEmpty,

    -- * Link
    Link (..),
    newLink,

    -- * Links
    Links (..),
    newLinks,

    -- * ListSpansResponse
    ListSpansResponse (..),
    newListSpansResponse,

    -- * ListTracesResponse
    ListTracesResponse (..),
    newListTracesResponse,

    -- * Module
    Module (..),
    newModule,

    -- * NetworkEvent
    NetworkEvent (..),
    newNetworkEvent,

    -- * Span
    Span (..),
    newSpan,

    -- * StackFrame
    StackFrame (..),
    newStackFrame,

    -- * StackFrames
    StackFrames (..),
    newStackFrames,

    -- * StackTrace
    StackTrace (..),
    newStackTrace,

    -- * Status
    Status (..),
    newStatus,

    -- * Status_DetailsItem
    Status_DetailsItem (..),
    newStatus_DetailsItem,

    -- * TimeEvent
    TimeEvent (..),
    newTimeEvent,

    -- * TimeEvents
    TimeEvents (..),
    newTimeEvents,

    -- * Trace
    Trace (..),
    newTrace,

    -- * TruncatableString
    TruncatableString (..),
    newTruncatableString,
  )
where

import Gogol.Prelude qualified as Core
import Gogol.Tracing.Internal.Sum

-- | Text annotation with a set of attributes. A maximum of 32 annotations are allowed per Span.
--
-- /See:/ 'newAnnotation' smart constructor.
data Annotation = Annotation
  { -- | A set of attributes on the annotation. A maximum of 4 attributes are allowed per Annotation.
    attributes :: (Core.Maybe Attributes),
    -- | A user-supplied message describing the event. The maximum length for the description is 256 bytes.
    description :: (Core.Maybe TruncatableString)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Annotation' with the minimum fields required to make a request.
newAnnotation ::
  Annotation
newAnnotation =
  Annotation {attributes = Core.Nothing, description = Core.Nothing}

instance Core.FromJSON Annotation where
  parseJSON =
    Core.withObject
      "Annotation"
      ( \o ->
          Annotation
            Core.<$> (o Core..:? "attributes")
            Core.<*> (o Core..:? "description")
      )

instance Core.ToJSON Annotation where
  toJSON Annotation {..} =
    Core.object
      ( Core.catMaybes
          [ ("attributes" Core..=) Core.<$> attributes,
            ("description" Core..=) Core.<$> description
          ]
      )

-- | The allowed types for the value side of an attribute key:value pair.
--
-- /See:/ 'newAttributeValue' smart constructor.
data AttributeValue = AttributeValue
  { -- | A boolean value.
    boolValue :: (Core.Maybe Core.Bool),
    -- | An integer value.
    intValue :: (Core.Maybe Core.Int64),
    -- | A string value (up to 256 bytes).
    stringValue :: (Core.Maybe TruncatableString)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AttributeValue' with the minimum fields required to make a request.
newAttributeValue ::
  AttributeValue
newAttributeValue =
  AttributeValue
    { boolValue = Core.Nothing,
      intValue = Core.Nothing,
      stringValue = Core.Nothing
    }

instance Core.FromJSON AttributeValue where
  parseJSON =
    Core.withObject
      "AttributeValue"
      ( \o ->
          AttributeValue
            Core.<$> (o Core..:? "boolValue")
            Core.<*> (o Core..:? "intValue" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "stringValue")
      )

instance Core.ToJSON AttributeValue where
  toJSON AttributeValue {..} =
    Core.object
      ( Core.catMaybes
          [ ("boolValue" Core..=) Core.<$> boolValue,
            ("intValue" Core..=) Core.. Core.AsText Core.<$> intValue,
            ("stringValue" Core..=) Core.<$> stringValue
          ]
      )

-- | Attributes of a span with a key:value format.
--
-- /See:/ 'newAttributes' smart constructor.
data Attributes = Attributes
  { -- | The maximum key length is 128 bytes (attributes are dropped if the key size is larger than the maximum allowed). The value can be a string (up to 256 bytes), integer, or boolean (true\/false). Some common pair examples:
    --
    -- > "/instance_id": "my-instance"
    -- > "/zone": "us-central1-a"
    -- > "/grpc/peer_address": "ip:port" (dns, etc.)
    -- > "/grpc/deadline": "Duration"
    -- > "/http/user_agent"
    -- > "/http/request_bytes": 300
    -- > "/http/response_bytes": 1200
    -- > "/http/url": google.com/apis
    -- > "abc.com/myattribute": true
    attributeMap :: (Core.Maybe Attributes_AttributeMap),
    -- | The number of dropped attributes after the maximum size was enforced. If 0 then no attributes were dropped.
    droppedAttributesCount :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Attributes' with the minimum fields required to make a request.
newAttributes ::
  Attributes
newAttributes =
  Attributes
    { attributeMap = Core.Nothing,
      droppedAttributesCount = Core.Nothing
    }

instance Core.FromJSON Attributes where
  parseJSON =
    Core.withObject
      "Attributes"
      ( \o ->
          Attributes
            Core.<$> (o Core..:? "attributeMap")
            Core.<*> (o Core..:? "droppedAttributesCount")
      )

instance Core.ToJSON Attributes where
  toJSON Attributes {..} =
    Core.object
      ( Core.catMaybes
          [ ("attributeMap" Core..=) Core.<$> attributeMap,
            ("droppedAttributesCount" Core..=)
              Core.<$> droppedAttributesCount
          ]
      )

-- | The maximum key length is 128 bytes (attributes are dropped if the key size is larger than the maximum allowed). The value can be a string (up to 256 bytes), integer, or boolean (true\/false). Some common pair examples:
--
-- > "/instance_id": "my-instance"
-- > "/zone": "us-central1-a"
-- > "/grpc/peer_address": "ip:port" (dns, etc.)
-- > "/grpc/deadline": "Duration"
-- > "/http/user_agent"
-- > "/http/request_bytes": 300
-- > "/http/response_bytes": 1200
-- > "/http/url": google.com/apis
-- > "abc.com/myattribute": true
--
-- /See:/ 'newAttributes_AttributeMap' smart constructor.
newtype Attributes_AttributeMap = Attributes_AttributeMap
  { additional :: (Core.HashMap Core.Text AttributeValue)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Attributes_AttributeMap' with the minimum fields required to make a request.
newAttributes_AttributeMap ::
  -- |  See 'additional'.
  Core.HashMap Core.Text AttributeValue ->
  Attributes_AttributeMap
newAttributes_AttributeMap additional =
  Attributes_AttributeMap {additional = additional}

instance Core.FromJSON Attributes_AttributeMap where
  parseJSON =
    Core.withObject
      "Attributes_AttributeMap"
      (\o -> Attributes_AttributeMap Core.<$> (Core.parseJSONObject o))

instance Core.ToJSON Attributes_AttributeMap where
  toJSON Attributes_AttributeMap {..} = Core.toJSON additional

-- | The request message for the @BatchWriteSpans@ method.
--
-- /See:/ 'newBatchWriteSpansRequest' smart constructor.
newtype BatchWriteSpansRequest = BatchWriteSpansRequest
  { -- | A collection of spans.
    spans :: (Core.Maybe [Span])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'BatchWriteSpansRequest' with the minimum fields required to make a request.
newBatchWriteSpansRequest ::
  BatchWriteSpansRequest
newBatchWriteSpansRequest =
  BatchWriteSpansRequest {spans = Core.Nothing}

instance Core.FromJSON BatchWriteSpansRequest where
  parseJSON =
    Core.withObject
      "BatchWriteSpansRequest"
      (\o -> BatchWriteSpansRequest Core.<$> (o Core..:? "spans"))

instance Core.ToJSON BatchWriteSpansRequest where
  toJSON BatchWriteSpansRequest {..} =
    Core.object (Core.catMaybes [("spans" Core..=) Core.<$> spans])

-- | A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance:
--
-- > service Foo {
-- >   rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
-- > }
--
-- The JSON representation for @Empty@ is empty JSON object @{}@.
--
-- /See:/ 'newEmpty' smart constructor.
data Empty = Empty
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Empty' with the minimum fields required to make a request.
newEmpty ::
  Empty
newEmpty = Empty

instance Core.FromJSON Empty where
  parseJSON = Core.withObject "Empty" (\o -> Core.pure Empty)

instance Core.ToJSON Empty where
  toJSON = Core.const Core.emptyObject

-- | A pointer from this span to another span in a different @Trace@ within the same service project or within a different service project. Used (for example) in batching operations, where a single batch handler processes multiple requests from different traces or when receives a request from a different service project.
--
-- /See:/ 'newLink' smart constructor.
data Link = Link
  { -- | @SPAN_ID@ is a unique identifier for a span within a trace. It is a base16-encoded, case-insensitive string of a 8-bytes array and is required to be 16 char long.
    spanId :: (Core.Maybe Core.Text),
    -- | @TRACE_ID@ is a unique identifier for a trace within a project. It is a base16-encoded, case-insensitive string of a 16-bytes array and is required to be 32 char long.
    traceId :: (Core.Maybe Core.Text),
    -- | The relationship of the current span relative to the linked span.
    type' :: (Core.Maybe Link_Type)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Link' with the minimum fields required to make a request.
newLink ::
  Link
newLink =
  Link
    { spanId = Core.Nothing,
      traceId = Core.Nothing,
      type' = Core.Nothing
    }

instance Core.FromJSON Link where
  parseJSON =
    Core.withObject
      "Link"
      ( \o ->
          Link
            Core.<$> (o Core..:? "spanId")
            Core.<*> (o Core..:? "traceId")
            Core.<*> (o Core..:? "type")
      )

instance Core.ToJSON Link where
  toJSON Link {..} =
    Core.object
      ( Core.catMaybes
          [ ("spanId" Core..=) Core.<$> spanId,
            ("traceId" Core..=) Core.<$> traceId,
            ("type" Core..=) Core.<$> type'
          ]
      )

-- | A collection of links, which are references from this span to a span in the same or different trace.
--
-- /See:/ 'newLinks' smart constructor.
data Links = Links
  { -- | The number of dropped links after the maximum size was enforced. If 0 then no links were dropped.
    droppedLinksCount :: (Core.Maybe Core.Int32),
    -- | A collection of links.
    link :: (Core.Maybe [Link])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Links' with the minimum fields required to make a request.
newLinks ::
  Links
newLinks =
  Links {droppedLinksCount = Core.Nothing, link = Core.Nothing}

instance Core.FromJSON Links where
  parseJSON =
    Core.withObject
      "Links"
      ( \o ->
          Links
            Core.<$> (o Core..:? "droppedLinksCount")
            Core.<*> (o Core..:? "link")
      )

instance Core.ToJSON Links where
  toJSON Links {..} =
    Core.object
      ( Core.catMaybes
          [ ("droppedLinksCount" Core..=) Core.<$> droppedLinksCount,
            ("link" Core..=) Core.<$> link
          ]
      )

-- | The response message for the @ListSpans@ method.
--
-- /See:/ 'newListSpansResponse' smart constructor.
data ListSpansResponse = ListSpansResponse
  { -- | If defined, indicates that there are more spans that match the request. Pass this as the value of @pageToken@ in a subsequent request to retrieve additional spans.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | The requested spans if there are any in the specified trace.
    spans :: (Core.Maybe [Span])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListSpansResponse' with the minimum fields required to make a request.
newListSpansResponse ::
  ListSpansResponse
newListSpansResponse =
  ListSpansResponse
    { nextPageToken = Core.Nothing,
      spans = Core.Nothing
    }

instance Core.FromJSON ListSpansResponse where
  parseJSON =
    Core.withObject
      "ListSpansResponse"
      ( \o ->
          ListSpansResponse
            Core.<$> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "spans")
      )

instance Core.ToJSON ListSpansResponse where
  toJSON ListSpansResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("spans" Core..=) Core.<$> spans
          ]
      )

-- | The response message for the @ListTraces@ method.
--
-- /See:/ 'newListTracesResponse' smart constructor.
data ListTracesResponse = ListTracesResponse
  { -- | If defined, indicates that there are more traces that match the request and that this value should be passed to the next request to continue retrieving additional traces.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | List of trace records returned.
    traces :: (Core.Maybe [Trace])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListTracesResponse' with the minimum fields required to make a request.
newListTracesResponse ::
  ListTracesResponse
newListTracesResponse =
  ListTracesResponse
    { nextPageToken = Core.Nothing,
      traces = Core.Nothing
    }

instance Core.FromJSON ListTracesResponse where
  parseJSON =
    Core.withObject
      "ListTracesResponse"
      ( \o ->
          ListTracesResponse
            Core.<$> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "traces")
      )

instance Core.ToJSON ListTracesResponse where
  toJSON ListTracesResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("traces" Core..=) Core.<$> traces
          ]
      )

-- | Binary module.
--
-- /See:/ 'newModule' smart constructor.
data Module = Module
  { -- | Build_id is a unique identifier for the module, usually a hash of its contents (up to 128 characters).
    buildId :: (Core.Maybe TruncatableString),
    -- | E.g. main binary, kernel modules, and dynamic libraries such as libc.so, sharedlib.so (up to 256 characters).
    module' :: (Core.Maybe TruncatableString)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Module' with the minimum fields required to make a request.
newModule ::
  Module
newModule = Module {buildId = Core.Nothing, module' = Core.Nothing}

instance Core.FromJSON Module where
  parseJSON =
    Core.withObject
      "Module"
      ( \o ->
          Module
            Core.<$> (o Core..:? "buildId")
            Core.<*> (o Core..:? "module")
      )

instance Core.ToJSON Module where
  toJSON Module {..} =
    Core.object
      ( Core.catMaybes
          [ ("buildId" Core..=) Core.<$> buildId,
            ("module" Core..=) Core.<$> module'
          ]
      )

-- | An event describing an RPC message sent\/received on the network. A maximum of 128 network events are allowed per Span.
--
-- /See:/ 'newNetworkEvent' smart constructor.
data NetworkEvent = NetworkEvent
  { -- | An identifier for the message, which must be unique in this span.
    messageId :: (Core.Maybe Core.Word64),
    -- | The number of bytes sent or received.
    messageSize :: (Core.Maybe Core.Word64),
    -- | If available, this is the kernel time:
    --
    -- -   For sent messages, this is the time at which the first bit was sent.
    -- -   For received messages, this is the time at which the last bit was received.
    time :: (Core.Maybe Core.DateTime),
    -- | Type of NetworkEvent. Indicates whether the RPC message was sent or received.
    type' :: (Core.Maybe NetworkEvent_Type)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'NetworkEvent' with the minimum fields required to make a request.
newNetworkEvent ::
  NetworkEvent
newNetworkEvent =
  NetworkEvent
    { messageId = Core.Nothing,
      messageSize = Core.Nothing,
      time = Core.Nothing,
      type' = Core.Nothing
    }

instance Core.FromJSON NetworkEvent where
  parseJSON =
    Core.withObject
      "NetworkEvent"
      ( \o ->
          NetworkEvent
            Core.<$> (o Core..:? "messageId" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "messageSize" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "time")
            Core.<*> (o Core..:? "type")
      )

instance Core.ToJSON NetworkEvent where
  toJSON NetworkEvent {..} =
    Core.object
      ( Core.catMaybes
          [ ("messageId" Core..=) Core.. Core.AsText Core.<$> messageId,
            ("messageSize" Core..=) Core.. Core.AsText Core.<$> messageSize,
            ("time" Core..=) Core.<$> time,
            ("type" Core..=) Core.<$> type'
          ]
      )

-- | A span represents a single operation within a trace. Spans can be nested to form a trace tree. Often, a trace contains a root span that describes the end-to-end latency and, optionally, one or more subspans for its sub-operations. (A trace could alternatively contain multiple root spans, or none at all.) Spans do not need to be contiguous. There may be gaps and\/or overlaps between spans in a trace.
--
-- /See:/ 'newSpan' smart constructor.
data Span = Span
  { -- | A set of attributes on the span. A maximum of 32 attributes are allowed per Span.
    attributes :: (Core.Maybe Attributes),
    -- | Description of the operation in the span. It is sanitized and displayed in the Stackdriver Trace tool in the {% dynamic print site/values.console/name %}. The display/name may be a method name or some other per-call site name. For the same executable and the same call point, a best practice is to use a consistent operation name, which makes it easier to correlate cross-trace spans. The maximum length for the display/name is 128 bytes.
    displayName :: (Core.Maybe TruncatableString),
    -- | End time of the span. On the client side, this is the local machine clock time at which the span execution was ended; on the server side, this is the time at which the server application handler stopped running.
    endTime :: (Core.Maybe Core.DateTime),
    -- | A maximum of 128 links are allowed per Span.
    links :: (Core.Maybe Links),
    -- | The resource name of Span in the format @projects\/PROJECT_ID\/traces\/TRACE_ID\/spans\/SPAN_ID@. @TRACE_ID@ is a unique identifier for a trace within a project and is a base16-encoded, case-insensitive string and is required to be 32 char long. @SPAN_ID@ is a unique identifier for a span within a trace. It is a base 16-encoded, case-insensitive string of a 8-bytes array and is required to be 16 char long.
    name :: (Core.Maybe Core.Text),
    -- | ID of parent span which is a base 16-encoded, case-insensitive string of a 8-bytes array and is required to be 16 char long. If this is a root span, the value must be empty.
    parentSpanId :: (Core.Maybe Core.Text),
    -- | Unique identifier for a span within a trace. It is a base 16-encoded, case-insensitive string of a 8-bytes array and is required.
    spanId :: (Core.Maybe Core.Text),
    -- | Stack trace captured at the start of the span.
    stackTrace :: (Core.Maybe StackTrace),
    -- | Start time of the span. On the client side, this is the local machine clock time at which the span execution was started; on the server side, this is the time at which the server application handler started running.
    startTime :: (Core.Maybe Core.DateTime),
    -- | An optional final status for this span.
    status :: (Core.Maybe Status),
    -- | A maximum of 32 annotations and 128 network events are allowed per Span.
    timeEvents :: (Core.Maybe TimeEvents)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Span' with the minimum fields required to make a request.
newSpan ::
  Span
newSpan =
  Span
    { attributes = Core.Nothing,
      displayName = Core.Nothing,
      endTime = Core.Nothing,
      links = Core.Nothing,
      name = Core.Nothing,
      parentSpanId = Core.Nothing,
      spanId = Core.Nothing,
      stackTrace = Core.Nothing,
      startTime = Core.Nothing,
      status = Core.Nothing,
      timeEvents = Core.Nothing
    }

instance Core.FromJSON Span where
  parseJSON =
    Core.withObject
      "Span"
      ( \o ->
          Span
            Core.<$> (o Core..:? "attributes")
            Core.<*> (o Core..:? "displayName")
            Core.<*> (o Core..:? "endTime")
            Core.<*> (o Core..:? "links")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "parentSpanId")
            Core.<*> (o Core..:? "spanId")
            Core.<*> (o Core..:? "stackTrace")
            Core.<*> (o Core..:? "startTime")
            Core.<*> (o Core..:? "status")
            Core.<*> (o Core..:? "timeEvents")
      )

instance Core.ToJSON Span where
  toJSON Span {..} =
    Core.object
      ( Core.catMaybes
          [ ("attributes" Core..=) Core.<$> attributes,
            ("displayName" Core..=) Core.<$> displayName,
            ("endTime" Core..=) Core.<$> endTime,
            ("links" Core..=) Core.<$> links,
            ("name" Core..=) Core.<$> name,
            ("parentSpanId" Core..=) Core.<$> parentSpanId,
            ("spanId" Core..=) Core.<$> spanId,
            ("stackTrace" Core..=) Core.<$> stackTrace,
            ("startTime" Core..=) Core.<$> startTime,
            ("status" Core..=) Core.<$> status,
            ("timeEvents" Core..=) Core.<$> timeEvents
          ]
      )

-- | Represents a single stack frame in a stack trace.
--
-- /See:/ 'newStackFrame' smart constructor.
data StackFrame = StackFrame
  { -- | Column number is important in JavaScript (anonymous functions). May not be available in some languages.
    columnNumber :: (Core.Maybe Core.Int64),
    -- | The filename of the file containing this frame (up to 256 characters).
    fileName :: (Core.Maybe TruncatableString),
    -- | The fully-qualified name that uniquely identifies this function or method (up to 1024 characters).
    functionName :: (Core.Maybe TruncatableString),
    -- | Line number of the frame.
    lineNumber :: (Core.Maybe Core.Int64),
    -- | Binary module the code is loaded from.
    loadModule :: (Core.Maybe Module),
    -- | Used when the function name is <http://www.avabodh.com/cxxin/namemangling.html mangled>. May be fully-qualified (up to 1024 characters).
    originalFunctionName :: (Core.Maybe TruncatableString),
    -- | The version of the deployed source code (up to 128 characters).
    sourceVersion :: (Core.Maybe TruncatableString)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'StackFrame' with the minimum fields required to make a request.
newStackFrame ::
  StackFrame
newStackFrame =
  StackFrame
    { columnNumber = Core.Nothing,
      fileName = Core.Nothing,
      functionName = Core.Nothing,
      lineNumber = Core.Nothing,
      loadModule = Core.Nothing,
      originalFunctionName = Core.Nothing,
      sourceVersion = Core.Nothing
    }

instance Core.FromJSON StackFrame where
  parseJSON =
    Core.withObject
      "StackFrame"
      ( \o ->
          StackFrame
            Core.<$> (o Core..:? "columnNumber" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "fileName")
            Core.<*> (o Core..:? "functionName")
            Core.<*> (o Core..:? "lineNumber" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "loadModule")
            Core.<*> (o Core..:? "originalFunctionName")
            Core.<*> (o Core..:? "sourceVersion")
      )

instance Core.ToJSON StackFrame where
  toJSON StackFrame {..} =
    Core.object
      ( Core.catMaybes
          [ ("columnNumber" Core..=) Core.. Core.AsText Core.<$> columnNumber,
            ("fileName" Core..=) Core.<$> fileName,
            ("functionName" Core..=) Core.<$> functionName,
            ("lineNumber" Core..=) Core.. Core.AsText Core.<$> lineNumber,
            ("loadModule" Core..=) Core.<$> loadModule,
            ("originalFunctionName" Core..=) Core.<$> originalFunctionName,
            ("sourceVersion" Core..=) Core.<$> sourceVersion
          ]
      )

-- | Represents collection of StackFrames that can be truncated.
--
-- /See:/ 'newStackFrames' smart constructor.
data StackFrames = StackFrames
  { -- | The number of dropped stack frames after the maximum size was enforced. If 0 then no frames were dropped.
    droppedFramesCount :: (Core.Maybe Core.Int32),
    -- | Stack frames in this stack trace.
    frame :: (Core.Maybe [StackFrame])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'StackFrames' with the minimum fields required to make a request.
newStackFrames ::
  StackFrames
newStackFrames =
  StackFrames
    { droppedFramesCount = Core.Nothing,
      frame = Core.Nothing
    }

instance Core.FromJSON StackFrames where
  parseJSON =
    Core.withObject
      "StackFrames"
      ( \o ->
          StackFrames
            Core.<$> (o Core..:? "droppedFramesCount")
            Core.<*> (o Core..:? "frame")
      )

instance Core.ToJSON StackFrames where
  toJSON StackFrames {..} =
    Core.object
      ( Core.catMaybes
          [ ("droppedFramesCount" Core..=) Core.<$> droppedFramesCount,
            ("frame" Core..=) Core.<$> frame
          ]
      )

-- | StackTrace collected in a trace.
--
-- /See:/ 'newStackTrace' smart constructor.
data StackTrace = StackTrace
  { -- | Stack frames in this stack trace. A maximum of 128 frames are allowed.
    stackFrames :: (Core.Maybe StackFrames),
    -- | The hash ID is used to conserve network bandwidth for duplicate stack traces within a single trace.
    --
    -- Often multiple spans will have identical stack traces. The first occurrence of a stack trace should contain both the @stackFrame@ content and a value in @stackTraceHashId@.
    --
    -- Subsequent spans within the same request can refer to that stack trace by only setting @stackTraceHashId@.
    stackTraceHashId :: (Core.Maybe Core.Word64)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'StackTrace' with the minimum fields required to make a request.
newStackTrace ::
  StackTrace
newStackTrace =
  StackTrace
    { stackFrames = Core.Nothing,
      stackTraceHashId = Core.Nothing
    }

instance Core.FromJSON StackTrace where
  parseJSON =
    Core.withObject
      "StackTrace"
      ( \o ->
          StackTrace
            Core.<$> (o Core..:? "stackFrames")
            Core.<*> (o Core..:? "stackTraceHashId" Core.<&> Core.fmap Core.fromAsText)
      )

instance Core.ToJSON StackTrace where
  toJSON StackTrace {..} =
    Core.object
      ( Core.catMaybes
          [ ("stackFrames" Core..=) Core.<$> stackFrames,
            ("stackTraceHashId" Core..=)
              Core.. Core.AsText
              Core.<$> stackTraceHashId
          ]
      )

-- | The @Status@ type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by <https://github.com/grpc gRPC>. The error model is designed to be:
--
-- -   Simple to use and understand for most users
-- -   Flexible enough to meet unexpected needs
--
-- = Overview
--
-- The @Status@ message contains three pieces of data: error code, error message, and error details. The error code should be an enum value of google.rpc.Code, but it may accept additional error codes if needed. The error message should be a developer-facing English message that helps developers /understand/ and /resolve/ the error. If a localized user-facing error message is needed, put the localized message in the error details or localize it in the client. The optional error details may contain arbitrary information about the error. There is a predefined set of error detail types in the package @google.rpc@ that can be used for common error conditions.
--
-- = Language mapping
--
-- The @Status@ message is the logical representation of the error model, but it is not necessarily the actual wire format. When the @Status@ message is exposed in different client libraries and different wire protocols, it can be mapped differently. For example, it will likely be mapped to some exceptions in Java, but more likely mapped to some error codes in C.
--
-- = Other uses
--
-- The error model and the @Status@ message can be used in a variety of environments, either with or without APIs, to provide a consistent developer experience across different environments.
--
-- Example uses of this error model include:
--
-- -   Partial errors. If a service needs to return partial errors to the client, it may embed the @Status@ in the normal response to indicate the partial errors.
--
-- -   Workflow errors. A typical workflow has multiple steps. Each step may have a @Status@ message for error reporting.
--
-- -   Batch operations. If a client uses batch request and batch response, the @Status@ message should be used directly inside batch response, one for each error sub-response.
--
-- -   Asynchronous operations. If an API call embeds asynchronous operation results in its response, the status of those operations should be represented directly using the @Status@ message.
--
-- -   Logging. If some API errors are stored in logs, the message @Status@ could be used directly after any stripping needed for security\/privacy reasons.
--
-- /See:/ 'newStatus' smart constructor.
data Status = Status
  { -- | The status code, which should be an enum value of google.rpc.Code.
    code :: (Core.Maybe Core.Int32),
    -- | A list of messages that carry the error details. There will be a common set of message types for APIs to use.
    details :: (Core.Maybe [Status_DetailsItem]),
    -- | A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
    message :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Status' with the minimum fields required to make a request.
newStatus ::
  Status
newStatus =
  Status
    { code = Core.Nothing,
      details = Core.Nothing,
      message = Core.Nothing
    }

instance Core.FromJSON Status where
  parseJSON =
    Core.withObject
      "Status"
      ( \o ->
          Status
            Core.<$> (o Core..:? "code")
            Core.<*> (o Core..:? "details")
            Core.<*> (o Core..:? "message")
      )

instance Core.ToJSON Status where
  toJSON Status {..} =
    Core.object
      ( Core.catMaybes
          [ ("code" Core..=) Core.<$> code,
            ("details" Core..=) Core.<$> details,
            ("message" Core..=) Core.<$> message
          ]
      )

--
-- /See:/ 'newStatus_DetailsItem' smart constructor.
newtype Status_DetailsItem = Status_DetailsItem
  { -- | Properties of the object. Contains field \@type with type URL.
    additional :: (Core.HashMap Core.Text Core.Value)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Status_DetailsItem' with the minimum fields required to make a request.
newStatus_DetailsItem ::
  -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
  Core.HashMap Core.Text Core.Value ->
  Status_DetailsItem
newStatus_DetailsItem additional =
  Status_DetailsItem {additional = additional}

instance Core.FromJSON Status_DetailsItem where
  parseJSON =
    Core.withObject
      "Status_DetailsItem"
      (\o -> Status_DetailsItem Core.<$> (Core.parseJSONObject o))

instance Core.ToJSON Status_DetailsItem where
  toJSON Status_DetailsItem {..} = Core.toJSON additional

-- | A time-stamped annotation in the Span.
--
-- /See:/ 'newTimeEvent' smart constructor.
data TimeEvent = TimeEvent
  { -- | One or more key:value pairs.
    annotation :: (Core.Maybe Annotation),
    -- | An event describing an RPC message sent\/received on the network.
    networkEvent :: (Core.Maybe NetworkEvent),
    -- | The timestamp indicating the time the event occurred.
    time :: (Core.Maybe Core.DateTime)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TimeEvent' with the minimum fields required to make a request.
newTimeEvent ::
  TimeEvent
newTimeEvent =
  TimeEvent
    { annotation = Core.Nothing,
      networkEvent = Core.Nothing,
      time = Core.Nothing
    }

instance Core.FromJSON TimeEvent where
  parseJSON =
    Core.withObject
      "TimeEvent"
      ( \o ->
          TimeEvent
            Core.<$> (o Core..:? "annotation")
            Core.<*> (o Core..:? "networkEvent")
            Core.<*> (o Core..:? "time")
      )

instance Core.ToJSON TimeEvent where
  toJSON TimeEvent {..} =
    Core.object
      ( Core.catMaybes
          [ ("annotation" Core..=) Core.<$> annotation,
            ("networkEvent" Core..=) Core.<$> networkEvent,
            ("time" Core..=) Core.<$> time
          ]
      )

-- | A collection of @TimeEvent@s. A @TimeEvent@ is a time-stamped annotation on the span, consisting of either user-supplied key:value pairs, or details of an RPC message sent\/received on the network.
--
-- /See:/ 'newTimeEvents' smart constructor.
data TimeEvents = TimeEvents
  { -- | The number of dropped annotations after the maximum size was enforced. If 0 then no annotations were dropped.
    droppedAnnotationsCount :: (Core.Maybe Core.Int32),
    -- | The number of dropped network events after the maximum size was enforced. If 0 then no annotations were dropped.
    droppedNetworkEventsCount :: (Core.Maybe Core.Int32),
    -- | A collection of @TimeEvent@s.
    timeEvent :: (Core.Maybe [TimeEvent])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TimeEvents' with the minimum fields required to make a request.
newTimeEvents ::
  TimeEvents
newTimeEvents =
  TimeEvents
    { droppedAnnotationsCount = Core.Nothing,
      droppedNetworkEventsCount = Core.Nothing,
      timeEvent = Core.Nothing
    }

instance Core.FromJSON TimeEvents where
  parseJSON =
    Core.withObject
      "TimeEvents"
      ( \o ->
          TimeEvents
            Core.<$> (o Core..:? "droppedAnnotationsCount")
            Core.<*> (o Core..:? "droppedNetworkEventsCount")
            Core.<*> (o Core..:? "timeEvent")
      )

instance Core.ToJSON TimeEvents where
  toJSON TimeEvents {..} =
    Core.object
      ( Core.catMaybes
          [ ("droppedAnnotationsCount" Core..=)
              Core.<$> droppedAnnotationsCount,
            ("droppedNetworkEventsCount" Core..=)
              Core.<$> droppedNetworkEventsCount,
            ("timeEvent" Core..=) Core.<$> timeEvent
          ]
      )

-- | A trace describes how long it takes for an application to perform some operations. It consists of a set of spans, each representing an operation and including time information and operation details.
--
-- /See:/ 'newTrace' smart constructor.
newtype Trace = Trace
  { -- | The resource name of Trace in the format @projects\/PROJECT_ID\/traces\/TRACE_ID@. @TRACE_ID@ is a unique identifier for a trace within a project and is a base16-encoded, case-insensitive string and is required to be 32 char long.
    name :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Trace' with the minimum fields required to make a request.
newTrace ::
  Trace
newTrace = Trace {name = Core.Nothing}

instance Core.FromJSON Trace where
  parseJSON =
    Core.withObject
      "Trace"
      (\o -> Trace Core.<$> (o Core..:? "name"))

instance Core.ToJSON Trace where
  toJSON Trace {..} =
    Core.object (Core.catMaybes [("name" Core..=) Core.<$> name])

-- | Represents a string value that might be truncated.
--
-- /See:/ 'newTruncatableString' smart constructor.
data TruncatableString = TruncatableString
  { -- | The number of characters truncated from the original string value. If 0 it means that the string value was not truncated.
    truncatedCharacterCount :: (Core.Maybe Core.Int32),
    -- | The truncated string value. E.g. for a string attribute this may have up to 256 bytes.
    value :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TruncatableString' with the minimum fields required to make a request.
newTruncatableString ::
  TruncatableString
newTruncatableString =
  TruncatableString
    { truncatedCharacterCount = Core.Nothing,
      value = Core.Nothing
    }

instance Core.FromJSON TruncatableString where
  parseJSON =
    Core.withObject
      "TruncatableString"
      ( \o ->
          TruncatableString
            Core.<$> (o Core..:? "truncatedCharacterCount")
            Core.<*> (o Core..:? "value")
      )

instance Core.ToJSON TruncatableString where
  toJSON TruncatableString {..} =
    Core.object
      ( Core.catMaybes
          [ ("truncatedCharacterCount" Core..=)
              Core.<$> truncatedCharacterCount,
            ("value" Core..=) Core.<$> value
          ]
      )