Bash variable contains a value from a set of values - bash

Question

I am developing a "wrapper script" to use as a "logging aid" in Bash.
It should print out information about the call stack at the time it was invoked.
I have done work on it, which follows, but a couple of questions/doubts remain and I'd like to get the best possible answer on them from the experts here.
My code:
################################################################################
# Formats a logging message.
function my_function_format_logging_message() {
local -r TIMESTAMP="$(date '+%H:%M:%S')"
local -r PROCESS="$$" # Deliberately not using $BASHPID, focus: parent process
local -r CALLER="${FUNCNAME[1]}"
local -i call_stack_position=1
if [[ "${CALLER}" == 'my_function_log_trace' ||
"${CALLER}" == 'my_function_log_debug' ||
"${CALLER}" == 'my_function_log_info' ||
"${CALLER}" == 'my_function_log_warning' ||
"${CALLER}" == 'my_function_log_error' ||
"${CALLER}" == 'my_function_log_critical' ]]
then
call_stack_position=$((call_stack_position++))
fi
local -r SOURCE="$(basename "${BASH_SOURCE[$call_stack_position]}")"
local -r FUNCTION="${FUNCNAME[$call_stack_position]}"
local -r LINE="${BASH_LINENO[$call_stack_position-1]}" # Previous function
local -r SEVERITY="$1"
local -r MESSAGE="$2"
# TODO: perform argument validation
printf '%s [PID %s] %s %s %s:%s - %s\n' \
"${TIMESTAMP}" \
"${PROCESS}" \
"${SEVERITY}" \
"${SOURCE}" \
"${FUNCTION}" \
"${LINE}" \
"${MESSAGE}"
}
################################################################################
Usage example:
my_function_format_logging_message CRITICAL Temporarily increasing energy level to 9001
or:
my_function_log_info Dropping back to power level 42
My doubts:
call_stack_position=$((call_stack_position++))
I can't think of a better way to increment this variable, is there a nicer/more readable form of this?
Can I use a better construct to detect if the call was made by a logging method? (e.g. trace, debug, info..). All of those if statements make my eyes hurt.
Am I reinventing the wheel / misusing the tool I'd like to learn? (i.e. shell scripting)
I might be reinventing the wheel, sure, but this is self-training.. to one day stop being a toll booth night-shift worker.
NOTE
I am looking for a match to the specified my_function_log_* names and no others. It is not ok to assume I have that degree of freedom (the many ifs are there for exactly that reason and I am looking for some syntactic sugar or better use of language features to do that type of "set membership" test).

Answer 1

I can suggest this for your first two questions:
if [[ "${CALLER}" == my_function_log_* ]]
then
let call_stack_position++
fi
If you just want a set of values after log_:
if [[ "${CALLER}" =~ my_function_log_(trace|debug|info|warning|error|critical) ]]
then
let call_stack_position++
fi

Answer 2

Bash’s type system, if you even want to call it that, is very rudimentary: strings and integers are its only first class citizens, arrays are a tacked on afterthought whose functionality is nowhere near that of Python sets or Ruby arrays. This being said, there is a poor man’s in operator for arrays that relies on string matching. Given an array of function names:
log_functions=(my_function_log_trace my_function_log_debug my_function_log_info my_function_log_warning my_function_log_error my_function_log_critical)
this:
[[ ${log_functions[*]} =~ \\b$CALLER\\b ]]
will match only members of the array. And as we are talking poor man’s constructs, you can combine the above pattern with boolean control operators into a poor man’s ternary assignment to skip the numerical evaluation altogether:
local -i call_stack_position=$([[ ${log_functions[*]} =~ \\b$CALLER\\b ]] && echo 1 || echo 2)
Caveat: on systems that do not support the GNU extensions to regcomp() (notably OS X and Cygwin), word boundary matching needs to use the somewhat more verbose character class form, i.e.
[[ ${log_functions[*]} =~ [[:\<:]]$CALLER[[:\>:]] ]]
Notes: seeing your code and noting you mentioned you are learning shell scripting, I’d offer two observations unrelated to the question proper:
The brace notation for variable expansion is only required for array access, expansion operations and to disambiguate var names in string concatenation. It is not needed in other cases, i.e. in both your tests and your printf command.
Using expansion string operations is much faster than using externals and thus recommended wherever possible. Instead of using basename, use ${var##*/}.

Answer 3

A more readable way of doing an increment is by incrementing it in numerical context:
(( call_stack_position++ ))
For the matching, you can use a glob in bash:
[[ $CALLER == my_function_log_* ]]
As far as reinventing the wheel, you can use syslog logging from bash using the logger command. The local syslog daemon will handle formatting the log message and writing it to a file.
logger -p local0.info "CRITICAL Temporarily increasing energy level to 9001"
Update, based on comments. You can use an associative array to be more explicit about what you are looking for. It requires bash v4 or higher.
declare -A arr=(
['my_function_log_trace']=1
['my_function_log_debug']=1
['my_function_log_info']=1
['my_function_log_warning']=1
['my_function_log_error']=1
['my_function_log_critical']=1
);
if [[ ${arr[CALLER]} ]]; then
...
fi
You could also use extended globbing for the pattern matching, similar to the regex in perreal's answer, but without regex:
shopt -s extglob
if [[ $CALLER == my_function_log_#(trace|debug|info|warning|error|critical) ]]; then
...
fi