class Sentry::LogEvent

@see develop.sentry.dev/sdk/telemetry/logs/#log-envelope-item-payload<br><br>Event type that represents a log entry with its attributes

def attribute_hash(value)

def attribute_hash(value)
  { value: value, type: value_type(value) }
end

def initialize(configuration: Sentry.configuration, **options)

def initialize(configuration: Sentry.configuration, **options)
  @configuration = configuration
  @type = TYPE
  @server_name = configuration.server_name
  @environment = configuration.environment
  @release = configuration.release
  @timestamp = Sentry.utc_now
  @level = options.fetch(:level)
  @body = options[:body]
  @template = @body if is_template?
  @attributes = options[:attributes] || DEFAULT_ATTRIBUTES
  @user = options[:user] || {}
  @contexts = {}
end

def is_template?

def is_template?
  body.include?("%s") || TOKEN_REGEXP.match?(body)
end

def parameters

def parameters
  @parameters ||= begin
    return DEFAULT_PARAMETERS unless template
    parameters = template_tokens.empty? ?
      attributes.fetch(:parameters, DEFAULT_PARAMETERS) : attributes.slice(*template_tokens)
    if parameters.is_a?(Hash)
      parameters.each do |key, value|
        attributes["sentry.message.parameter.#{key}"] = value
      end
    else
      parameters.each_with_index do |param, index|
        attributes["sentry.message.parameter.#{index}"] = param
      end
    end
  end
end

def serialize(name)

def serialize(name)
  serializer = SERIALIZERS[name]
  if serializer
    __send__(serializer)
  else
    public_send(name)
  end
end

def serialize_attributes

def serialize_attributes
  hash = {}
  attributes.each do |key, value|
    hash[key] = attribute_hash(value)
  end
  SENTRY_ATTRIBUTES.each do |key, name|
    if (value = serialize(name))
      hash[key] = attribute_hash(value)
    end
  end
  USER_ATTRIBUTES.each do |key, name|
    if (value = serialize(name))
      hash[key] = value
    end
  end
  hash
end

def serialize_body

def serialize_body
  if parameters.empty?
    body
  elsif parameters.is_a?(Hash)
    body % parameters
  else
    sprintf(body, *parameters)
  end
end

def serialize_level

def serialize_level
  level.to_s
end

def serialize_parent_span_id

def serialize_parent_span_id
  contexts.dig(:trace, :parent_span_id)
end

def serialize_sdk_name

def serialize_sdk_name
  Sentry.sdk_meta["name"]
end

def serialize_sdk_version

def serialize_sdk_version
  Sentry.sdk_meta["version"]
end

def serialize_timestamp

def serialize_timestamp
  timestamp.to_f
end

def serialize_trace_id

def serialize_trace_id
  contexts.dig(:trace, :trace_id)
end

def serialize_user_email

def serialize_user_email
  user[:email]
end

def serialize_user_id

def serialize_user_id
  user[:id]
end

def serialize_user_username

def serialize_user_username
  user[:username]
end

def template_tokens

def template_tokens
  @template_tokens ||= body.scan(TOKEN_REGEXP).flatten.map(&:to_sym)
end

def to_hash

def to_hash
  SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |name, memo|
    memo[name] = serialize(name)
  end
end

def value_type(value)

def value_type(value)
  VALUE_TYPES[value.class]
end