{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Greengrass.Types.GreengrassLogger
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Greengrass.Types.GreengrassLogger where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Greengrass.Types.LoggerComponent
import Amazonka.Greengrass.Types.LoggerLevel
import Amazonka.Greengrass.Types.LoggerType
import qualified Amazonka.Prelude as Prelude

-- | Information about a logger
--
-- /See:/ 'newGreengrassLogger' smart constructor.
data GreengrassLogger = GreengrassLogger'
  { -- | The amount of file space, in KB, to use if the local file system is used
    -- for logging purposes.
    GreengrassLogger -> Maybe Int
space :: Prelude.Maybe Prelude.Int,
    -- | The type of log output which will be used.
    GreengrassLogger -> LoggerType
type' :: LoggerType,
    -- | The level of the logs.
    GreengrassLogger -> LoggerLevel
level :: LoggerLevel,
    -- | A descriptive or arbitrary ID for the logger. This value must be unique
    -- within the logger definition version. Max length is 128 characters with
    -- pattern \'\'[a-zA-Z0-9:_-]+\'\'.
    GreengrassLogger -> Text
id :: Prelude.Text,
    -- | The component that will be subject to logging.
    GreengrassLogger -> LoggerComponent
component :: LoggerComponent
  }
  deriving (GreengrassLogger -> GreengrassLogger -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreengrassLogger -> GreengrassLogger -> Bool
$c/= :: GreengrassLogger -> GreengrassLogger -> Bool
== :: GreengrassLogger -> GreengrassLogger -> Bool
$c== :: GreengrassLogger -> GreengrassLogger -> Bool
Prelude.Eq, ReadPrec [GreengrassLogger]
ReadPrec GreengrassLogger
Int -> ReadS GreengrassLogger
ReadS [GreengrassLogger]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GreengrassLogger]
$creadListPrec :: ReadPrec [GreengrassLogger]
readPrec :: ReadPrec GreengrassLogger
$creadPrec :: ReadPrec GreengrassLogger
readList :: ReadS [GreengrassLogger]
$creadList :: ReadS [GreengrassLogger]
readsPrec :: Int -> ReadS GreengrassLogger
$creadsPrec :: Int -> ReadS GreengrassLogger
Prelude.Read, Int -> GreengrassLogger -> ShowS
[GreengrassLogger] -> ShowS
GreengrassLogger -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreengrassLogger] -> ShowS
$cshowList :: [GreengrassLogger] -> ShowS
show :: GreengrassLogger -> String
$cshow :: GreengrassLogger -> String
showsPrec :: Int -> GreengrassLogger -> ShowS
$cshowsPrec :: Int -> GreengrassLogger -> ShowS
Prelude.Show, forall x. Rep GreengrassLogger x -> GreengrassLogger
forall x. GreengrassLogger -> Rep GreengrassLogger x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreengrassLogger x -> GreengrassLogger
$cfrom :: forall x. GreengrassLogger -> Rep GreengrassLogger x
Prelude.Generic)

-- |
-- Create a value of 'GreengrassLogger' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'space', 'greengrassLogger_space' - The amount of file space, in KB, to use if the local file system is used
-- for logging purposes.
--
-- 'type'', 'greengrassLogger_type' - The type of log output which will be used.
--
-- 'level', 'greengrassLogger_level' - The level of the logs.
--
-- 'id', 'greengrassLogger_id' - A descriptive or arbitrary ID for the logger. This value must be unique
-- within the logger definition version. Max length is 128 characters with
-- pattern \'\'[a-zA-Z0-9:_-]+\'\'.
--
-- 'component', 'greengrassLogger_component' - The component that will be subject to logging.
newGreengrassLogger ::
  -- | 'type''
  LoggerType ->
  -- | 'level'
  LoggerLevel ->
  -- | 'id'
  Prelude.Text ->
  -- | 'component'
  LoggerComponent ->
  GreengrassLogger
newGreengrassLogger :: LoggerType
-> LoggerLevel -> Text -> LoggerComponent -> GreengrassLogger
newGreengrassLogger LoggerType
pType_ LoggerLevel
pLevel_ Text
pId_ LoggerComponent
pComponent_ =
  GreengrassLogger'
    { $sel:space:GreengrassLogger' :: Maybe Int
space = forall a. Maybe a
Prelude.Nothing,
      $sel:type':GreengrassLogger' :: LoggerType
type' = LoggerType
pType_,
      $sel:level:GreengrassLogger' :: LoggerLevel
level = LoggerLevel
pLevel_,
      $sel:id:GreengrassLogger' :: Text
id = Text
pId_,
      $sel:component:GreengrassLogger' :: LoggerComponent
component = LoggerComponent
pComponent_
    }

-- | The amount of file space, in KB, to use if the local file system is used
-- for logging purposes.
greengrassLogger_space :: Lens.Lens' GreengrassLogger (Prelude.Maybe Prelude.Int)
greengrassLogger_space :: Lens' GreengrassLogger (Maybe Int)
greengrassLogger_space = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GreengrassLogger' {Maybe Int
space :: Maybe Int
$sel:space:GreengrassLogger' :: GreengrassLogger -> Maybe Int
space} -> Maybe Int
space) (\s :: GreengrassLogger
s@GreengrassLogger' {} Maybe Int
a -> GreengrassLogger
s {$sel:space:GreengrassLogger' :: Maybe Int
space = Maybe Int
a} :: GreengrassLogger)

-- | The type of log output which will be used.
greengrassLogger_type :: Lens.Lens' GreengrassLogger LoggerType
greengrassLogger_type :: Lens' GreengrassLogger LoggerType
greengrassLogger_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GreengrassLogger' {LoggerType
type' :: LoggerType
$sel:type':GreengrassLogger' :: GreengrassLogger -> LoggerType
type'} -> LoggerType
type') (\s :: GreengrassLogger
s@GreengrassLogger' {} LoggerType
a -> GreengrassLogger
s {$sel:type':GreengrassLogger' :: LoggerType
type' = LoggerType
a} :: GreengrassLogger)

-- | The level of the logs.
greengrassLogger_level :: Lens.Lens' GreengrassLogger LoggerLevel
greengrassLogger_level :: Lens' GreengrassLogger LoggerLevel
greengrassLogger_level = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GreengrassLogger' {LoggerLevel
level :: LoggerLevel
$sel:level:GreengrassLogger' :: GreengrassLogger -> LoggerLevel
level} -> LoggerLevel
level) (\s :: GreengrassLogger
s@GreengrassLogger' {} LoggerLevel
a -> GreengrassLogger
s {$sel:level:GreengrassLogger' :: LoggerLevel
level = LoggerLevel
a} :: GreengrassLogger)

-- | A descriptive or arbitrary ID for the logger. This value must be unique
-- within the logger definition version. Max length is 128 characters with
-- pattern \'\'[a-zA-Z0-9:_-]+\'\'.
greengrassLogger_id :: Lens.Lens' GreengrassLogger Prelude.Text
greengrassLogger_id :: Lens' GreengrassLogger Text
greengrassLogger_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GreengrassLogger' {Text
id :: Text
$sel:id:GreengrassLogger' :: GreengrassLogger -> Text
id} -> Text
id) (\s :: GreengrassLogger
s@GreengrassLogger' {} Text
a -> GreengrassLogger
s {$sel:id:GreengrassLogger' :: Text
id = Text
a} :: GreengrassLogger)

-- | The component that will be subject to logging.
greengrassLogger_component :: Lens.Lens' GreengrassLogger LoggerComponent
greengrassLogger_component :: Lens' GreengrassLogger LoggerComponent
greengrassLogger_component = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GreengrassLogger' {LoggerComponent
component :: LoggerComponent
$sel:component:GreengrassLogger' :: GreengrassLogger -> LoggerComponent
component} -> LoggerComponent
component) (\s :: GreengrassLogger
s@GreengrassLogger' {} LoggerComponent
a -> GreengrassLogger
s {$sel:component:GreengrassLogger' :: LoggerComponent
component = LoggerComponent
a} :: GreengrassLogger)

instance Data.FromJSON GreengrassLogger where
  parseJSON :: Value -> Parser GreengrassLogger
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"GreengrassLogger"
      ( \Object
x ->
          Maybe Int
-> LoggerType
-> LoggerLevel
-> Text
-> LoggerComponent
-> GreengrassLogger
GreengrassLogger'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Space")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Type")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Level")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Id")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Component")
      )

instance Prelude.Hashable GreengrassLogger where
  hashWithSalt :: Int -> GreengrassLogger -> Int
hashWithSalt Int
_salt GreengrassLogger' {Maybe Int
Text
LoggerComponent
LoggerLevel
LoggerType
component :: LoggerComponent
id :: Text
level :: LoggerLevel
type' :: LoggerType
space :: Maybe Int
$sel:component:GreengrassLogger' :: GreengrassLogger -> LoggerComponent
$sel:id:GreengrassLogger' :: GreengrassLogger -> Text
$sel:level:GreengrassLogger' :: GreengrassLogger -> LoggerLevel
$sel:type':GreengrassLogger' :: GreengrassLogger -> LoggerType
$sel:space:GreengrassLogger' :: GreengrassLogger -> Maybe Int
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
space
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` LoggerType
type'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` LoggerLevel
level
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
id
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` LoggerComponent
component

instance Prelude.NFData GreengrassLogger where
  rnf :: GreengrassLogger -> ()
rnf GreengrassLogger' {Maybe Int
Text
LoggerComponent
LoggerLevel
LoggerType
component :: LoggerComponent
id :: Text
level :: LoggerLevel
type' :: LoggerType
space :: Maybe Int
$sel:component:GreengrassLogger' :: GreengrassLogger -> LoggerComponent
$sel:id:GreengrassLogger' :: GreengrassLogger -> Text
$sel:level:GreengrassLogger' :: GreengrassLogger -> LoggerLevel
$sel:type':GreengrassLogger' :: GreengrassLogger -> LoggerType
$sel:space:GreengrassLogger' :: GreengrassLogger -> Maybe Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
space
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf LoggerType
type'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf LoggerLevel
level
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf LoggerComponent
component

instance Data.ToJSON GreengrassLogger where
  toJSON :: GreengrassLogger -> Value
toJSON GreengrassLogger' {Maybe Int
Text
LoggerComponent
LoggerLevel
LoggerType
component :: LoggerComponent
id :: Text
level :: LoggerLevel
type' :: LoggerType
space :: Maybe Int
$sel:component:GreengrassLogger' :: GreengrassLogger -> LoggerComponent
$sel:id:GreengrassLogger' :: GreengrassLogger -> Text
$sel:level:GreengrassLogger' :: GreengrassLogger -> LoggerLevel
$sel:type':GreengrassLogger' :: GreengrassLogger -> LoggerType
$sel:space:GreengrassLogger' :: GreengrassLogger -> Maybe Int
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Space" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
space,
            forall a. a -> Maybe a
Prelude.Just (Key
"Type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= LoggerType
type'),
            forall a. a -> Maybe a
Prelude.Just (Key
"Level" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= LoggerLevel
level),
            forall a. a -> Maybe a
Prelude.Just (Key
"Id" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
id),
            forall a. a -> Maybe a
Prelude.Just (Key
"Component" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= LoggerComponent
component)
          ]
      )