.functions_logging

#----- header -----
[ "${0##*/}" != "${BASH_SOURCE##*/}" ] || { >&2 echo -e "ERROR\tfile must be sourced ($0)"; return 2; }

# prevent multiple-inclusion
__link=`readlink -f "$BASH_SOURCE"`
declare -n __tag=SOURCE_${__link//[^a-zA-Z0-9_]/}
[ ${__tag:-0} = 0 ] || return 0
__tag=1
#------------------


#LOG_TIMESTAMP=0
#LOG_STACKTRACE=0
#LOG_LEVEL=INFO
: ${LOG_MASK:=WARN}
#LOG_FORMAT=

# reference https://code.woboq.org/gcc/include/sys/syslog.h.html
# syslog.h has DEBUG=7 ... EMERG=0 while Java/Python/Ruby(?) define as DEBUG=0 ... EMERG=7

declare -Arx __log_levels=(
    [EMERG]=0   [PANIC]=0
    [0]='EMERG'
    [ALERT]=1
    [1]='ALERT'
    [CRIT]=2    [CRITICAL]=2
#    [FATAL]=2
    [2]='CRIT'
    [ERR]=3     [ERROR]=3
    [3]='ERROR'
    [WARN]=4    [WARNING]=4
    [4]='WARN'
    [NOTICE]=5
    [5]='NOTICE'
    [INFO]=6
    [6]='INFO'
    [DEBUG]=7
    [7]='DEBUG'
    # Java'ish extensions
    [TRACE]=8   [FINE]=8
    [8]='TRACE'
#    [FINEST]=9
)

declare -arx LOG_FACILITIES=(
    auth authpriv cron daemon kern lpr mail news syslog user uucp local{0..7}
  )


function log.mask() {
  [ -n "$1" ] || { echo "${LOG_MASK:-unset}"; return; }

  [ -n "${__log_levels[${1:-x}]}" ] && LOG_MASK="$1" || log_ERROR "invalid level ($1)"
}
readonly -f log.mask


#TODO function __log_verbose __log_debug {
#  local _level=${VERBOSE:=$DEBUG}
# DEBUG>1 will lower LOG_MASK into TRACE
# call this individually for DEBUG and VERBOSE
#
#  case "$_level" in
#    -*) ;;  # ignore like '-v -d'
#
#    [4-9])  VERBOSE=3 ;&
#    [1-3])
#            [ -n "$DEBUG" ] || : $((_level--))
#            [ $_level -eq 0 ] ||
#_VERBOSE="-`printf -- '%.0sv' {1..$_level}`"
#        }
#        ;;&
#    3)  LOG_MASK='DEBUG' ;;
#    2)  LOG_MASK='INFO' ;;
#    1)  LOG_MASK='NOTICE' ;;
#    0|'') unset LOG_MASK ;;     # defaults to >NOTICE
#    *)  error "invalid level ($_level) from VERBOSE or DEBUG"
#  esac
#  [ -n "$DEBUG" ] && LOG_MASK='DEBUG'
#}


# recycleable function template
read -rd '' __log_template <<'EOF'
{
  local -i rc=$? _exit RC

  log "$@"
  [ ${_exit:-0} -eq 1 ] || return ${RC:-$rc}

  # check nesting level, inside script, or screen
  if [ ${SHLVL:-1} -eq 1 -o -z "$BASH_SOURCE" ] ||
     [[ `\ps -p $PPID | awk 'END { print $NF; }'` =~  screen ]]; then
    return ${RC:-$rc}
  fi

  __continue || exit ${RC:-$rc}
}
EOF

for k in "${!__log_levels[@]}"; do
  case "${__log_levels[$k]}" in
    # silence output
    [0-3])  eval function log_$k "${__log_template/_exit/_exit=1}" 2>/dev/null
            ;;
    [4-8])  eval function log_$k "${__log_template}" 2>/dev/null
            ;;
    *)      continue
  esac
  readonly -f log_$k

  # define new naming style
  overwrite=1 copy_function "log_$k" "log.${k,,}" 2>/dev/null
  overwrite=1 copy_function "log_$k" "log.$k" 2>/dev/null
  readonly -f "log.${k,,}" "log.$k"
done
unset k  __log_template
unset -f __log_exit


function __log_lookup() {
  # lookup level by either type of key
  # returns numeric value only !!

  local -u key=$1; key=${key#LOG[._]}
  local result=${__log_levels[${key:-X}]}

  [ -n "$result" ] || { echo -1; return 1; }

  [[ $result == [0-8] ]] && echo "$result" || echo "$key"
}
readonly -f __log_lookup


function log() {
  local -i level mask offset=1

  # auto-detect level from invocation style
  if level=`__log_lookup ${level:-$LOG_LEVEL}`; then
    # LOG_LEVEL=<level> log "msg"
    :
  elif level=`__log_lookup "$1"`; then
    # log <level> "msg"
    shift
  else
    # inside recursion from <level>() or log_<LEVEL>()
    level=`__log_lookup "${FUNCNAME[1]}"` && ((offset++))
  fi

  mask=`__log_lookup ${mask:-$LOG_MASK}`

  # set 'mask' on externalities
  [ -n "$VERBOSE" ] && mask=`__log_lookup 'INFO'`

  if [ -n "$DEBUG" ]; then
    mask=`__log_lookup 'DEBUG'`

    # increase level if (DEBUG > 1)
    local -i _mask=$((mask + DEBUG - 1))
    [ $_mask -gt $mask ] && _mask=`__log_lookup $_mask` && mask=$_mask
  fi

  # sanity check
  [[ ${level:-X} == [0-8] ]] || level=`__log_lookup 'INFO'`
  [[ ${mask:-X}  == [0-8] ]] || mask=`__log_lookup 'WARN'`

  # squelch messages below mask
  [ $level -le $mask ] || return 0

  if [ -n "$LOG_STACKTRACE" -a "${FUNCNAME[1]}" != "$FUNCNAME" ]; then
    local -a msg=()

    for ((i=${#FUNCNAME[@]}-1; i>0; i--))  do
      msg+=("callstack: ${BASH_SOURCE[i]}/${FUNCNAME[i]}")
    done
    # prevent recursion loop with 'offset' value - see L:176
    mask='TRACE' level='TRACE' offset=2 $FUNCNAME "${msg[@]}"
  fi

  local fname= level_name=${__log_levels[$level]}
  local logger_bin=`is_exec -v "${LOGGER:-logger}"`

  # embed FUNCNAME in output
  [ -n "${FUNCNAME[offset]}" -a "${FUNCNAME[1]}" != "$FUNCNAME" ] &&
      fname="[${BASH_SOURCE[offset]##*/}:${FUNCNAME[offset]}] "

  if [ $# -eq 0 ]; then
    local input=$( < /dev/stdin )
    __log_print "$input"
  else
    while (( $# )); do __log_print "$1"; shift; done
  fi
}
readonly -f log


function __log_print() {
  local line format=${LOG_FORMAT:-'%-5s\t%s'}

  printf -v line "${LOG_TIMESTAMP:+`date '+%FT%T.%3N'` }${format}" "$level_name" "${fname}$1"
  >&2 echo -e "$line" | tee ${LOGFILE:+'-a' "$LOGFILE"}

  if [ -n "${SYSLOG}" -a -n "$logger_bin" ]; then
    "$logger_bin" --priority user.${level_name,,} -- "$line"
  fi
}
readonly -f __log_print

# vim: expandtab:ts=8:sw=4