sensu-plugins-mongodb-mrtrotl 1.4.0

data/lib/pymongo/event_loggers.py

@@ -0,0 +1,221 @@
+# Copyright 2020-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""Example event logger classes.
+
+.. versionadded:: 3.11
+
+These loggers can be registered using :func:`register` or
+:class:`~pymongo.mongo_client.MongoClient`.
+
+``monitoring.register(CommandLogger())``
+
+or
+
+``MongoClient(event_listeners=[CommandLogger()])``
+"""
+import logging
+
+from pymongo import monitoring
+
+
+class CommandLogger(monitoring.CommandListener):
+    """A simple listener that logs command events.
+
+    Listens for :class:`~pymongo.monitoring.CommandStartedEvent`,
+    :class:`~pymongo.monitoring.CommandSucceededEvent` and
+    :class:`~pymongo.monitoring.CommandFailedEvent` events and
+    logs them at the `INFO` severity level using :mod:`logging`.
+    .. versionadded:: 3.11
+    """
+
+    def started(self, event: monitoring.CommandStartedEvent) -> None:
+        logging.info(
+            f"Command {event.command_name} with request id "
+            f"{event.request_id} started on server "
+            f"{event.connection_id}"
+        )
+
+    def succeeded(self, event: monitoring.CommandSucceededEvent) -> None:
+        logging.info(
+            f"Command {event.command_name} with request id "
+            f"{event.request_id} on server {event.connection_id} "
+            f"succeeded in {event.duration_micros} "
+            "microseconds"
+        )
+
+    def failed(self, event: monitoring.CommandFailedEvent) -> None:
+        logging.info(
+            f"Command {event.command_name} with request id "
+            f"{event.request_id} on server {event.connection_id} "
+            f"failed in {event.duration_micros} "
+            "microseconds"
+        )
+
+
+class ServerLogger(monitoring.ServerListener):
+    """A simple listener that logs server discovery events.
+
+    Listens for :class:`~pymongo.monitoring.ServerOpeningEvent`,
+    :class:`~pymongo.monitoring.ServerDescriptionChangedEvent`,
+    and :class:`~pymongo.monitoring.ServerClosedEvent`
+    events and logs them at the `INFO` severity level using :mod:`logging`.
+
+    .. versionadded:: 3.11
+    """
+
+    def opened(self, event: monitoring.ServerOpeningEvent) -> None:
+        logging.info(f"Server {event.server_address} added to topology {event.topology_id}")
+
+    def description_changed(self, event: monitoring.ServerDescriptionChangedEvent) -> None:
+        previous_server_type = event.previous_description.server_type
+        new_server_type = event.new_description.server_type
+        if new_server_type != previous_server_type:
+            # server_type_name was added in PyMongo 3.4
+            logging.info(
+                f"Server {event.server_address} changed type from "
+                f"{event.previous_description.server_type_name} to "
+                f"{event.new_description.server_type_name}"
+            )
+
+    def closed(self, event: monitoring.ServerClosedEvent) -> None:
+        logging.warning(f"Server {event.server_address} removed from topology {event.topology_id}")
+
+
+class HeartbeatLogger(monitoring.ServerHeartbeatListener):
+    """A simple listener that logs server heartbeat events.
+
+    Listens for :class:`~pymongo.monitoring.ServerHeartbeatStartedEvent`,
+    :class:`~pymongo.monitoring.ServerHeartbeatSucceededEvent`,
+    and :class:`~pymongo.monitoring.ServerHeartbeatFailedEvent`
+    events and logs them at the `INFO` severity level using :mod:`logging`.
+
+    .. versionadded:: 3.11
+    """
+
+    def started(self, event: monitoring.ServerHeartbeatStartedEvent) -> None:
+        logging.info(f"Heartbeat sent to server {event.connection_id}")
+
+    def succeeded(self, event: monitoring.ServerHeartbeatSucceededEvent) -> None:
+        # The reply.document attribute was added in PyMongo 3.4.
+        logging.info(
+            f"Heartbeat to server {event.connection_id} "
+            "succeeded with reply "
+            f"{event.reply.document}"
+        )
+
+    def failed(self, event: monitoring.ServerHeartbeatFailedEvent) -> None:
+        logging.warning(
+            f"Heartbeat to server {event.connection_id} failed with error {event.reply}"
+        )
+
+
+class TopologyLogger(monitoring.TopologyListener):
+    """A simple listener that logs server topology events.
+
+    Listens for :class:`~pymongo.monitoring.TopologyOpenedEvent`,
+    :class:`~pymongo.monitoring.TopologyDescriptionChangedEvent`,
+    and :class:`~pymongo.monitoring.TopologyClosedEvent`
+    events and logs them at the `INFO` severity level using :mod:`logging`.
+
+    .. versionadded:: 3.11
+    """
+
+    def opened(self, event: monitoring.TopologyOpenedEvent) -> None:
+        logging.info(f"Topology with id {event.topology_id} opened")
+
+    def description_changed(self, event: monitoring.TopologyDescriptionChangedEvent) -> None:
+        logging.info(f"Topology description updated for topology id {event.topology_id}")
+        previous_topology_type = event.previous_description.topology_type
+        new_topology_type = event.new_description.topology_type
+        if new_topology_type != previous_topology_type:
+            # topology_type_name was added in PyMongo 3.4
+            logging.info(
+                f"Topology {event.topology_id} changed type from "
+                f"{event.previous_description.topology_type_name} to "
+                f"{event.new_description.topology_type_name}"
+            )
+        # The has_writable_server and has_readable_server methods
+        # were added in PyMongo 3.4.
+        if not event.new_description.has_writable_server():
+            logging.warning("No writable servers available.")
+        if not event.new_description.has_readable_server():
+            logging.warning("No readable servers available.")
+
+    def closed(self, event: monitoring.TopologyClosedEvent) -> None:
+        logging.info(f"Topology with id {event.topology_id} closed")
+
+
+class ConnectionPoolLogger(monitoring.ConnectionPoolListener):
+    """A simple listener that logs server connection pool events.
+
+    Listens for :class:`~pymongo.monitoring.PoolCreatedEvent`,
+    :class:`~pymongo.monitoring.PoolClearedEvent`,
+    :class:`~pymongo.monitoring.PoolClosedEvent`,
+    :~pymongo.monitoring.class:`ConnectionCreatedEvent`,
+    :class:`~pymongo.monitoring.ConnectionReadyEvent`,
+    :class:`~pymongo.monitoring.ConnectionClosedEvent`,
+    :class:`~pymongo.monitoring.ConnectionCheckOutStartedEvent`,
+    :class:`~pymongo.monitoring.ConnectionCheckOutFailedEvent`,
+    :class:`~pymongo.monitoring.ConnectionCheckedOutEvent`,
+    and :class:`~pymongo.monitoring.ConnectionCheckedInEvent`
+    events and logs them at the `INFO` severity level using :mod:`logging`.
+
+    .. versionadded:: 3.11
+    """
+
+    def pool_created(self, event: monitoring.PoolCreatedEvent) -> None:
+        logging.info(f"[pool {event.address}] pool created")
+
+    def pool_ready(self, event):
+        logging.info(f"[pool {event.address}] pool ready")
+
+    def pool_cleared(self, event: monitoring.PoolClearedEvent) -> None:
+        logging.info(f"[pool {event.address}] pool cleared")
+
+    def pool_closed(self, event: monitoring.PoolClosedEvent) -> None:
+        logging.info(f"[pool {event.address}] pool closed")
+
+    def connection_created(self, event: monitoring.ConnectionCreatedEvent) -> None:
+        logging.info(f"[pool {event.address}][conn #{event.connection_id}] connection created")
+
+    def connection_ready(self, event: monitoring.ConnectionReadyEvent) -> None:
+        logging.info(
+            f"[pool {event.address}][conn #{event.connection_id}] connection setup succeeded"
+        )
+
+    def connection_closed(self, event: monitoring.ConnectionClosedEvent) -> None:
+        logging.info(
+            f"[pool {event.address}][conn #{event.connection_id}] "
+            f'connection closed, reason: "{event.reason}"'
+        )
+
+    def connection_check_out_started(
+        self, event: monitoring.ConnectionCheckOutStartedEvent
+    ) -> None:
+        logging.info(f"[pool {event.address}] connection check out started")
+
+    def connection_check_out_failed(self, event: monitoring.ConnectionCheckOutFailedEvent) -> None:
+        logging.info(f"[pool {event.address}] connection check out failed, reason: {event.reason}")
+
+    def connection_checked_out(self, event: monitoring.ConnectionCheckedOutEvent) -> None:
+        logging.info(
+            f"[pool {event.address}][conn #{event.connection_id}] connection checked out of pool"
+        )
+
+    def connection_checked_in(self, event: monitoring.ConnectionCheckedInEvent) -> None:
+        logging.info(
+            f"[pool {event.address}][conn #{event.connection_id}] connection checked into pool"
+        )

data/lib/pymongo/hello.py

@@ -0,0 +1,219 @@
+# Copyright 2021-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Helpers for the 'hello' and legacy hello commands."""
+
+import copy
+import datetime
+import itertools
+from typing import Any, Generic, List, Mapping, Optional, Set, Tuple
+
+from bson.objectid import ObjectId
+from pymongo import common
+from pymongo.server_type import SERVER_TYPE
+from pymongo.typings import _DocumentType
+
+
+class HelloCompat:
+    CMD = "hello"
+    LEGACY_CMD = "ismaster"
+    PRIMARY = "isWritablePrimary"
+    LEGACY_PRIMARY = "ismaster"
+    LEGACY_ERROR = "not master"
+
+
+def _get_server_type(doc):
+    """Determine the server type from a hello response."""
+    if not doc.get("ok"):
+        return SERVER_TYPE.Unknown
+
+    if doc.get("serviceId"):
+        return SERVER_TYPE.LoadBalancer
+    elif doc.get("isreplicaset"):
+        return SERVER_TYPE.RSGhost
+    elif doc.get("setName"):
+        if doc.get("hidden"):
+            return SERVER_TYPE.RSOther
+        elif doc.get(HelloCompat.PRIMARY):
+            return SERVER_TYPE.RSPrimary
+        elif doc.get(HelloCompat.LEGACY_PRIMARY):
+            return SERVER_TYPE.RSPrimary
+        elif doc.get("secondary"):
+            return SERVER_TYPE.RSSecondary
+        elif doc.get("arbiterOnly"):
+            return SERVER_TYPE.RSArbiter
+        else:
+            return SERVER_TYPE.RSOther
+    elif doc.get("msg") == "isdbgrid":
+        return SERVER_TYPE.Mongos
+    else:
+        return SERVER_TYPE.Standalone
+
+
+class Hello(Generic[_DocumentType]):
+    """Parse a hello response from the server.
+
+    .. versionadded:: 3.12
+    """
+
+    __slots__ = ("_doc", "_server_type", "_is_writable", "_is_readable", "_awaitable")
+
+    def __init__(self, doc: _DocumentType, awaitable: bool = False) -> None:
+        self._server_type = _get_server_type(doc)
+        self._doc: _DocumentType = doc
+        self._is_writable = self._server_type in (
+            SERVER_TYPE.RSPrimary,
+            SERVER_TYPE.Standalone,
+            SERVER_TYPE.Mongos,
+            SERVER_TYPE.LoadBalancer,
+        )
+
+        self._is_readable = self.server_type == SERVER_TYPE.RSSecondary or self._is_writable
+        self._awaitable = awaitable
+
+    @property
+    def document(self) -> _DocumentType:
+        """The complete hello command response document.
+
+        .. versionadded:: 3.4
+        """
+        return copy.copy(self._doc)
+
+    @property
+    def server_type(self) -> int:
+        return self._server_type
+
+    @property
+    def all_hosts(self) -> Set[Tuple[str, int]]:
+        """List of hosts, passives, and arbiters known to this server."""
+        return set(
+            map(
+                common.clean_node,
+                itertools.chain(
+                    self._doc.get("hosts", []),
+                    self._doc.get("passives", []),
+                    self._doc.get("arbiters", []),
+                ),
+            )
+        )
+
+    @property
+    def tags(self) -> Mapping[str, Any]:
+        """Replica set member tags or empty dict."""
+        return self._doc.get("tags", {})
+
+    @property
+    def primary(self) -> Optional[Tuple[str, int]]:
+        """This server's opinion about who the primary is, or None."""
+        if self._doc.get("primary"):
+            return common.partition_node(self._doc["primary"])
+        else:
+            return None
+
+    @property
+    def replica_set_name(self) -> Optional[str]:
+        """Replica set name or None."""
+        return self._doc.get("setName")
+
+    @property
+    def max_bson_size(self) -> int:
+        return self._doc.get("maxBsonObjectSize", common.MAX_BSON_SIZE)
+
+    @property
+    def max_message_size(self) -> int:
+        return self._doc.get("maxMessageSizeBytes", 2 * self.max_bson_size)
+
+    @property
+    def max_write_batch_size(self) -> int:
+        return self._doc.get("maxWriteBatchSize", common.MAX_WRITE_BATCH_SIZE)
+
+    @property
+    def min_wire_version(self) -> int:
+        return self._doc.get("minWireVersion", common.MIN_WIRE_VERSION)
+
+    @property
+    def max_wire_version(self) -> int:
+        return self._doc.get("maxWireVersion", common.MAX_WIRE_VERSION)
+
+    @property
+    def set_version(self) -> Optional[int]:
+        return self._doc.get("setVersion")
+
+    @property
+    def election_id(self) -> Optional[ObjectId]:
+        return self._doc.get("electionId")
+
+    @property
+    def cluster_time(self) -> Optional[Mapping[str, Any]]:
+        return self._doc.get("$clusterTime")
+
+    @property
+    def logical_session_timeout_minutes(self) -> Optional[int]:
+        return self._doc.get("logicalSessionTimeoutMinutes")
+
+    @property
+    def is_writable(self) -> bool:
+        return self._is_writable
+
+    @property
+    def is_readable(self) -> bool:
+        return self._is_readable
+
+    @property
+    def me(self) -> Optional[Tuple[str, int]]:
+        me = self._doc.get("me")
+        if me:
+            return common.clean_node(me)
+        return None
+
+    @property
+    def last_write_date(self) -> Optional[datetime.datetime]:
+        return self._doc.get("lastWrite", {}).get("lastWriteDate")
+
+    @property
+    def compressors(self) -> Optional[List[str]]:
+        return self._doc.get("compression")
+
+    @property
+    def sasl_supported_mechs(self) -> List[str]:
+        """Supported authentication mechanisms for the current user.
+
+        For example::
+
+            >>> hello.sasl_supported_mechs
+            ["SCRAM-SHA-1", "SCRAM-SHA-256"]
+
+        """
+        return self._doc.get("saslSupportedMechs", [])
+
+    @property
+    def speculative_authenticate(self) -> Optional[Mapping[str, Any]]:
+        """The speculativeAuthenticate field."""
+        return self._doc.get("speculativeAuthenticate")
+
+    @property
+    def topology_version(self) -> Optional[Mapping[str, Any]]:
+        return self._doc.get("topologyVersion")
+
+    @property
+    def awaitable(self) -> bool:
+        return self._awaitable
+
+    @property
+    def service_id(self) -> Optional[ObjectId]:
+        return self._doc.get("serviceId")
+
+    @property
+    def hello_ok(self) -> bool:
+        return self._doc.get("helloOk", False)

data/lib/pymongo/helpers.py

@@ -0,0 +1,259 @@
+# Copyright 2009-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Bits and pieces used by the driver that don't really fit elsewhere."""
+
+import sys
+import traceback
+from collections import abc
+from typing import Any, List, NoReturn
+
+from bson.son import SON
+from pymongo import ASCENDING
+from pymongo.errors import (
+    CursorNotFound,
+    DuplicateKeyError,
+    ExecutionTimeout,
+    NotPrimaryError,
+    OperationFailure,
+    WriteConcernError,
+    WriteError,
+    WTimeoutError,
+    _wtimeout_error,
+)
+from pymongo.hello import HelloCompat
+
+# From the SDAM spec, the "node is shutting down" codes.
+_SHUTDOWN_CODES = frozenset(
+    [
+        11600,  # InterruptedAtShutdown
+        91,  # ShutdownInProgress
+    ]
+)
+# From the SDAM spec, the "not primary" error codes are combined with the
+# "node is recovering" error codes (of which the "node is shutting down"
+# errors are a subset).
+_NOT_PRIMARY_CODES = (
+    frozenset(
+        [
+            10058,  # LegacyNotPrimary <=3.2 "not primary" error code
+            10107,  # NotWritablePrimary
+            13435,  # NotPrimaryNoSecondaryOk
+            11602,  # InterruptedDueToReplStateChange
+            13436,  # NotPrimaryOrSecondary
+            189,  # PrimarySteppedDown
+        ]
+    )
+    | _SHUTDOWN_CODES
+)
+# From the retryable writes spec.
+_RETRYABLE_ERROR_CODES = _NOT_PRIMARY_CODES | frozenset(
+    [
+        7,  # HostNotFound
+        6,  # HostUnreachable
+        89,  # NetworkTimeout
+        9001,  # SocketException
+        262,  # ExceededTimeLimit
+    ]
+)
+
+
+def _gen_index_name(keys):
+    """Generate an index name from the set of fields it is over."""
+    return "_".join(["%s_%s" % item for item in keys])
+
+
+def _index_list(key_or_list, direction=None):
+    """Helper to generate a list of (key, direction) pairs.
+
+    Takes such a list, or a single key, or a single key and direction.
+    """
+    if direction is not None:
+        return [(key_or_list, direction)]
+    else:
+        if isinstance(key_or_list, str):
+            return [(key_or_list, ASCENDING)]
+        if isinstance(key_or_list, abc.ItemsView):
+            return list(key_or_list)
+        elif not isinstance(key_or_list, (list, tuple)):
+            raise TypeError("if no direction is specified, key_or_list must be an instance of list")
+        return key_or_list
+
+
+def _index_document(index_list):
+    """Helper to generate an index specifying document.
+
+    Takes a list of (key, direction) pairs.
+    """
+    if isinstance(index_list, abc.Mapping):
+        raise TypeError(
+            "passing a dict to sort/create_index/hint is not "
+            "allowed - use a list of tuples instead. did you "
+            "mean %r?" % list(index_list.items())
+        )
+    elif not isinstance(index_list, (list, tuple)):
+        raise TypeError("must use a list of (key, direction) pairs, not: " + repr(index_list))
+    if not len(index_list):
+        raise ValueError("key_or_list must not be the empty list")
+
+    index: SON[str, Any] = SON()
+    for (key, value) in index_list:
+        if not isinstance(key, str):
+            raise TypeError("first item in each key pair must be an instance of str")
+        if not isinstance(value, (str, int, abc.Mapping)):
+            raise TypeError(
+                "second item in each key pair must be 1, -1, "
+                "'2d', or another valid MongoDB index specifier."
+            )
+        index[key] = value
+    return index
+
+
+def _check_command_response(
+    response, max_wire_version, allowable_errors=None, parse_write_concern_error=False
+):
+    """Check the response to a command for errors."""
+    if "ok" not in response:
+        # Server didn't recognize our message as a command.
+        raise OperationFailure(
+            response.get("$err"), response.get("code"), response, max_wire_version
+        )
+
+    if parse_write_concern_error and "writeConcernError" in response:
+        _error = response["writeConcernError"]
+        _labels = response.get("errorLabels")
+        if _labels:
+            _error.update({"errorLabels": _labels})
+        _raise_write_concern_error(_error)
+
+    if response["ok"]:
+        return
+
+    details = response
+    # Mongos returns the error details in a 'raw' object
+    # for some errors.
+    if "raw" in response:
+        for shard in response["raw"].values():
+            # Grab the first non-empty raw error from a shard.
+            if shard.get("errmsg") and not shard.get("ok"):
+                details = shard
+                break
+
+    errmsg = details["errmsg"]
+    code = details.get("code")
+
+    # For allowable errors, only check for error messages when the code is not
+    # included.
+    if allowable_errors:
+        if code is not None:
+            if code in allowable_errors:
+                return
+        elif errmsg in allowable_errors:
+            return
+
+    # Server is "not primary" or "recovering"
+    if code is not None:
+        if code in _NOT_PRIMARY_CODES:
+            raise NotPrimaryError(errmsg, response)
+    elif HelloCompat.LEGACY_ERROR in errmsg or "node is recovering" in errmsg:
+        raise NotPrimaryError(errmsg, response)
+
+    # Other errors
+    # findAndModify with upsert can raise duplicate key error
+    if code in (11000, 11001, 12582):
+        raise DuplicateKeyError(errmsg, code, response, max_wire_version)
+    elif code == 50:
+        raise ExecutionTimeout(errmsg, code, response, max_wire_version)
+    elif code == 43:
+        raise CursorNotFound(errmsg, code, response, max_wire_version)
+
+    raise OperationFailure(errmsg, code, response, max_wire_version)
+
+
+def _raise_last_write_error(write_errors: List[Any]) -> NoReturn:
+    # If the last batch had multiple errors only report
+    # the last error to emulate continue_on_error.
+    error = write_errors[-1]
+    if error.get("code") == 11000:
+        raise DuplicateKeyError(error.get("errmsg"), 11000, error)
+    raise WriteError(error.get("errmsg"), error.get("code"), error)
+
+
+def _raise_write_concern_error(error: Any) -> NoReturn:
+    if _wtimeout_error(error):
+        # Make sure we raise WTimeoutError
+        raise WTimeoutError(error.get("errmsg"), error.get("code"), error)
+    raise WriteConcernError(error.get("errmsg"), error.get("code"), error)
+
+
+def _get_wce_doc(result):
+    """Return the writeConcernError or None."""
+    wce = result.get("writeConcernError")
+    if wce:
+        # The server reports errorLabels at the top level but it's more
+        # convenient to attach it to the writeConcernError doc itself.
+        error_labels = result.get("errorLabels")
+        if error_labels:
+            wce["errorLabels"] = error_labels
+    return wce
+
+
+def _check_write_command_response(result):
+    """Backward compatibility helper for write command error handling."""
+    # Prefer write errors over write concern errors
+    write_errors = result.get("writeErrors")
+    if write_errors:
+        _raise_last_write_error(write_errors)
+
+    wce = _get_wce_doc(result)
+    if wce:
+        _raise_write_concern_error(wce)
+
+
+def _fields_list_to_dict(fields, option_name):
+    """Takes a sequence of field names and returns a matching dictionary.
+
+    ["a", "b"] becomes {"a": 1, "b": 1}
+
+    and
+
+    ["a.b.c", "d", "a.c"] becomes {"a.b.c": 1, "d": 1, "a.c": 1}
+    """
+    if isinstance(fields, abc.Mapping):
+        return fields
+
+    if isinstance(fields, (abc.Sequence, abc.Set)):
+        if not all(isinstance(field, str) for field in fields):
+            raise TypeError(
+                "%s must be a list of key names, each an instance of str" % (option_name,)
+            )
+        return dict.fromkeys(fields, 1)
+
+    raise TypeError("%s must be a mapping or list of key names" % (option_name,))
+
+
+def _handle_exception():
+    """Print exceptions raised by subscribers to stderr."""
+    # Heavily influenced by logging.Handler.handleError.
+
+    # See note here:
+    # https://docs.python.org/3.4/library/sys.html#sys.__stderr__
+    if sys.stderr:
+        einfo = sys.exc_info()
+        try:
+            traceback.print_exception(einfo[0], einfo[1], einfo[2], None, sys.stderr)
+        except IOError:
+            pass
+        finally:
+            del einfo